GET domains.projects.locations.list
{{baseUrl}}/v1/:+name/locations
QUERY PARAMS

name
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+name/locations");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+name/locations")
require "http/client"

url = "{{baseUrl}}/v1/:+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}}/v1/:+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}}/v1/:+name/locations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+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/v1/:+name/locations HTTP/1.1
Host: example.com

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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+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}}/v1/:+name/locations');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/:+name/locations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+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}}/v1/:+name/locations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+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/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+name/locations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+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}}/v1/:+name/locations');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+name/locations');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+name/locations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+name/locations' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+name/locations' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+name/locations")

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

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

url = "{{baseUrl}}/v1/:+name/locations"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+name/locations"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+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/v1/:+name/locations') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+name/locations'
http GET '{{baseUrl}}/v1/:+name/locations'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+name/locations'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+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()
GET domains.projects.locations.operations.list
{{baseUrl}}/v1/:+name/operations
QUERY PARAMS

name
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+name/operations");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+name/operations")
require "http/client"

url = "{{baseUrl}}/v1/:+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}}/v1/:+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}}/v1/:+name/operations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+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/v1/:+name/operations HTTP/1.1
Host: example.com

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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+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}}/v1/:+name/operations');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/:+name/operations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+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}}/v1/:+name/operations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+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/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+name/operations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+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}}/v1/:+name/operations');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+name/operations');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+name/operations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+name/operations' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+name/operations' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+name/operations")

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

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

url = "{{baseUrl}}/v1/:+name/operations"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+name/operations"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+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/v1/:+name/operations') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+name/operations'
http GET '{{baseUrl}}/v1/:+name/operations'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+name/operations'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+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()
POST domains.projects.locations.registrations.configureContactSettings
{{baseUrl}}/v1/:+registration:configureContactSettings
QUERY PARAMS

registration
BODY json

{
  "contactNotices": [],
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "updateMask": "",
  "validateOnly": false
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+registration:configureContactSettings");

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  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/:+registration:configureContactSettings" {:content-type :json
                                                                                       :form-params {:contactNotices []
                                                                                                     :contactSettings {:adminContact {:email ""
                                                                                                                                      :faxNumber ""
                                                                                                                                      :phoneNumber ""
                                                                                                                                      :postalAddress {:addressLines []
                                                                                                                                                      :administrativeArea ""
                                                                                                                                                      :languageCode ""
                                                                                                                                                      :locality ""
                                                                                                                                                      :organization ""
                                                                                                                                                      :postalCode ""
                                                                                                                                                      :recipients []
                                                                                                                                                      :regionCode ""
                                                                                                                                                      :revision 0
                                                                                                                                                      :sortingCode ""
                                                                                                                                                      :sublocality ""}}
                                                                                                                       :privacy ""
                                                                                                                       :registrantContact {}
                                                                                                                       :technicalContact {}}
                                                                                                     :updateMask ""
                                                                                                     :validateOnly false}})
require "http/client"

url = "{{baseUrl}}/v1/:+registration:configureContactSettings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/:+registration:configureContactSettings"),
    Content = new StringContent("{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+registration:configureContactSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+registration:configureContactSettings"

	payload := strings.NewReader("{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}")

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

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

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

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

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

}
POST /baseUrl/v1/:+registration:configureContactSettings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 599

{
  "contactNotices": [],
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "updateMask": "",
  "validateOnly": false
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:+registration:configureContactSettings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+registration:configureContactSettings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:configureContactSettings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+registration:configureContactSettings")
  .header("content-type", "application/json")
  .body("{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}")
  .asString();
const data = JSON.stringify({
  contactNotices: [],
  contactSettings: {
    adminContact: {
      email: '',
      faxNumber: '',
      phoneNumber: '',
      postalAddress: {
        addressLines: [],
        administrativeArea: '',
        languageCode: '',
        locality: '',
        organization: '',
        postalCode: '',
        recipients: [],
        regionCode: '',
        revision: 0,
        sortingCode: '',
        sublocality: ''
      }
    },
    privacy: '',
    registrantContact: {},
    technicalContact: {}
  },
  updateMask: '',
  validateOnly: false
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/:+registration:configureContactSettings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:configureContactSettings',
  headers: {'content-type': 'application/json'},
  data: {
    contactNotices: [],
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    updateMask: '',
    validateOnly: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+registration:configureContactSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contactNotices":[],"contactSettings":{"adminContact":{"email":"","faxNumber":"","phoneNumber":"","postalAddress":{"addressLines":[],"administrativeArea":"","languageCode":"","locality":"","organization":"","postalCode":"","recipients":[],"regionCode":"","revision":0,"sortingCode":"","sublocality":""}},"privacy":"","registrantContact":{},"technicalContact":{}},"updateMask":"","validateOnly":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/:+registration:configureContactSettings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "contactNotices": [],\n  "contactSettings": {\n    "adminContact": {\n      "email": "",\n      "faxNumber": "",\n      "phoneNumber": "",\n      "postalAddress": {\n        "addressLines": [],\n        "administrativeArea": "",\n        "languageCode": "",\n        "locality": "",\n        "organization": "",\n        "postalCode": "",\n        "recipients": [],\n        "regionCode": "",\n        "revision": 0,\n        "sortingCode": "",\n        "sublocality": ""\n      }\n    },\n    "privacy": "",\n    "registrantContact": {},\n    "technicalContact": {}\n  },\n  "updateMask": "",\n  "validateOnly": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:configureContactSettings")
  .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/v1/:+registration:configureContactSettings',
  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({
  contactNotices: [],
  contactSettings: {
    adminContact: {
      email: '',
      faxNumber: '',
      phoneNumber: '',
      postalAddress: {
        addressLines: [],
        administrativeArea: '',
        languageCode: '',
        locality: '',
        organization: '',
        postalCode: '',
        recipients: [],
        regionCode: '',
        revision: 0,
        sortingCode: '',
        sublocality: ''
      }
    },
    privacy: '',
    registrantContact: {},
    technicalContact: {}
  },
  updateMask: '',
  validateOnly: false
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:configureContactSettings',
  headers: {'content-type': 'application/json'},
  body: {
    contactNotices: [],
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    updateMask: '',
    validateOnly: false
  },
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/:+registration:configureContactSettings');

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

req.type('json');
req.send({
  contactNotices: [],
  contactSettings: {
    adminContact: {
      email: '',
      faxNumber: '',
      phoneNumber: '',
      postalAddress: {
        addressLines: [],
        administrativeArea: '',
        languageCode: '',
        locality: '',
        organization: '',
        postalCode: '',
        recipients: [],
        regionCode: '',
        revision: 0,
        sortingCode: '',
        sublocality: ''
      }
    },
    privacy: '',
    registrantContact: {},
    technicalContact: {}
  },
  updateMask: '',
  validateOnly: false
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:configureContactSettings',
  headers: {'content-type': 'application/json'},
  data: {
    contactNotices: [],
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    updateMask: '',
    validateOnly: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+registration:configureContactSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contactNotices":[],"contactSettings":{"adminContact":{"email":"","faxNumber":"","phoneNumber":"","postalAddress":{"addressLines":[],"administrativeArea":"","languageCode":"","locality":"","organization":"","postalCode":"","recipients":[],"regionCode":"","revision":0,"sortingCode":"","sublocality":""}},"privacy":"","registrantContact":{},"technicalContact":{}},"updateMask":"","validateOnly":false}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"contactNotices": @[  ],
                              @"contactSettings": @{ @"adminContact": @{ @"email": @"", @"faxNumber": @"", @"phoneNumber": @"", @"postalAddress": @{ @"addressLines": @[  ], @"administrativeArea": @"", @"languageCode": @"", @"locality": @"", @"organization": @"", @"postalCode": @"", @"recipients": @[  ], @"regionCode": @"", @"revision": @0, @"sortingCode": @"", @"sublocality": @"" } }, @"privacy": @"", @"registrantContact": @{  }, @"technicalContact": @{  } },
                              @"updateMask": @"",
                              @"validateOnly": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:+registration:configureContactSettings"]
                                                       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}}/v1/:+registration:configureContactSettings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+registration:configureContactSettings",
  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([
    'contactNotices' => [
        
    ],
    'contactSettings' => [
        'adminContact' => [
                'email' => '',
                'faxNumber' => '',
                'phoneNumber' => '',
                'postalAddress' => [
                                'addressLines' => [
                                                                
                                ],
                                'administrativeArea' => '',
                                'languageCode' => '',
                                'locality' => '',
                                'organization' => '',
                                'postalCode' => '',
                                'recipients' => [
                                                                
                                ],
                                'regionCode' => '',
                                'revision' => 0,
                                'sortingCode' => '',
                                'sublocality' => ''
                ]
        ],
        'privacy' => '',
        'registrantContact' => [
                
        ],
        'technicalContact' => [
                
        ]
    ],
    'updateMask' => '',
    'validateOnly' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/:+registration:configureContactSettings', [
  'body' => '{
  "contactNotices": [],
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "updateMask": "",
  "validateOnly": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+registration:configureContactSettings');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'contactNotices' => [
    
  ],
  'contactSettings' => [
    'adminContact' => [
        'email' => '',
        'faxNumber' => '',
        'phoneNumber' => '',
        'postalAddress' => [
                'addressLines' => [
                                
                ],
                'administrativeArea' => '',
                'languageCode' => '',
                'locality' => '',
                'organization' => '',
                'postalCode' => '',
                'recipients' => [
                                
                ],
                'regionCode' => '',
                'revision' => 0,
                'sortingCode' => '',
                'sublocality' => ''
        ]
    ],
    'privacy' => '',
    'registrantContact' => [
        
    ],
    'technicalContact' => [
        
    ]
  ],
  'updateMask' => '',
  'validateOnly' => null
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'contactNotices' => [
    
  ],
  'contactSettings' => [
    'adminContact' => [
        'email' => '',
        'faxNumber' => '',
        'phoneNumber' => '',
        'postalAddress' => [
                'addressLines' => [
                                
                ],
                'administrativeArea' => '',
                'languageCode' => '',
                'locality' => '',
                'organization' => '',
                'postalCode' => '',
                'recipients' => [
                                
                ],
                'regionCode' => '',
                'revision' => 0,
                'sortingCode' => '',
                'sublocality' => ''
        ]
    ],
    'privacy' => '',
    'registrantContact' => [
        
    ],
    'technicalContact' => [
        
    ]
  ],
  'updateMask' => '',
  'validateOnly' => null
]));
$request->setRequestUrl('{{baseUrl}}/v1/:+registration:configureContactSettings');
$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}}/v1/:+registration:configureContactSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contactNotices": [],
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "updateMask": "",
  "validateOnly": false
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+registration:configureContactSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contactNotices": [],
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "updateMask": "",
  "validateOnly": false
}'
import http.client

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

payload = "{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"

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

conn.request("POST", "/baseUrl/v1/:+registration:configureContactSettings", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+registration:configureContactSettings"

payload = {
    "contactNotices": [],
    "contactSettings": {
        "adminContact": {
            "email": "",
            "faxNumber": "",
            "phoneNumber": "",
            "postalAddress": {
                "addressLines": [],
                "administrativeArea": "",
                "languageCode": "",
                "locality": "",
                "organization": "",
                "postalCode": "",
                "recipients": [],
                "regionCode": "",
                "revision": 0,
                "sortingCode": "",
                "sublocality": ""
            }
        },
        "privacy": "",
        "registrantContact": {},
        "technicalContact": {}
    },
    "updateMask": "",
    "validateOnly": False
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+registration:configureContactSettings"

payload <- "{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+registration:configureContactSettings")

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  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/v1/:+registration:configureContactSettings') do |req|
  req.body = "{\n  \"contactNotices\": [],\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+registration:configureContactSettings";

    let payload = json!({
        "contactNotices": (),
        "contactSettings": json!({
            "adminContact": json!({
                "email": "",
                "faxNumber": "",
                "phoneNumber": "",
                "postalAddress": json!({
                    "addressLines": (),
                    "administrativeArea": "",
                    "languageCode": "",
                    "locality": "",
                    "organization": "",
                    "postalCode": "",
                    "recipients": (),
                    "regionCode": "",
                    "revision": 0,
                    "sortingCode": "",
                    "sublocality": ""
                })
            }),
            "privacy": "",
            "registrantContact": json!({}),
            "technicalContact": json!({})
        }),
        "updateMask": "",
        "validateOnly": false
    });

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

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

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

    dbg!(results);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+registration:configureContactSettings' \
  --header 'content-type: application/json' \
  --data '{
  "contactNotices": [],
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "updateMask": "",
  "validateOnly": false
}'
echo '{
  "contactNotices": [],
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "updateMask": "",
  "validateOnly": false
}' |  \
  http POST '{{baseUrl}}/v1/:+registration:configureContactSettings' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "contactNotices": [],\n  "contactSettings": {\n    "adminContact": {\n      "email": "",\n      "faxNumber": "",\n      "phoneNumber": "",\n      "postalAddress": {\n        "addressLines": [],\n        "administrativeArea": "",\n        "languageCode": "",\n        "locality": "",\n        "organization": "",\n        "postalCode": "",\n        "recipients": [],\n        "regionCode": "",\n        "revision": 0,\n        "sortingCode": "",\n        "sublocality": ""\n      }\n    },\n    "privacy": "",\n    "registrantContact": {},\n    "technicalContact": {}\n  },\n  "updateMask": "",\n  "validateOnly": false\n}' \
  --output-document \
  - '{{baseUrl}}/v1/:+registration:configureContactSettings'
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "contactNotices": [],
  "contactSettings": [
    "adminContact": [
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": [
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      ]
    ],
    "privacy": "",
    "registrantContact": [],
    "technicalContact": []
  ],
  "updateMask": "",
  "validateOnly": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+registration:configureContactSettings")! 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()
POST domains.projects.locations.registrations.configureDnsSettings
{{baseUrl}}/v1/:+registration:configureDnsSettings
QUERY PARAMS

registration
BODY json

{
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "updateMask": "",
  "validateOnly": false
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+registration:configureDnsSettings");

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  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/:+registration:configureDnsSettings" {:content-type :json
                                                                                   :form-params {:dnsSettings {:customDns {:dsRecords [{:algorithm ""
                                                                                                                                        :digest ""
                                                                                                                                        :digestType ""
                                                                                                                                        :keyTag 0}]
                                                                                                                           :nameServers []}
                                                                                                               :glueRecords [{:hostName ""
                                                                                                                              :ipv4Addresses []
                                                                                                                              :ipv6Addresses []}]
                                                                                                               :googleDomainsDns {:dsRecords [{}]
                                                                                                                                  :dsState ""
                                                                                                                                  :nameServers []}
                                                                                                               :googleDomainsRedirectsDataAvailable false}
                                                                                                 :updateMask ""
                                                                                                 :validateOnly false}})
require "http/client"

url = "{{baseUrl}}/v1/:+registration:configureDnsSettings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/:+registration:configureDnsSettings"),
    Content = new StringContent("{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+registration:configureDnsSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+registration:configureDnsSettings"

	payload := strings.NewReader("{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}")

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

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

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

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

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

}
POST /baseUrl/v1/:+registration:configureDnsSettings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 565

{
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "updateMask": "",
  "validateOnly": false
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:+registration:configureDnsSettings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+registration:configureDnsSettings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:configureDnsSettings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+registration:configureDnsSettings")
  .header("content-type", "application/json")
  .body("{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}")
  .asString();
const data = JSON.stringify({
  dnsSettings: {
    customDns: {
      dsRecords: [
        {
          algorithm: '',
          digest: '',
          digestType: '',
          keyTag: 0
        }
      ],
      nameServers: []
    },
    glueRecords: [
      {
        hostName: '',
        ipv4Addresses: [],
        ipv6Addresses: []
      }
    ],
    googleDomainsDns: {
      dsRecords: [
        {}
      ],
      dsState: '',
      nameServers: []
    },
    googleDomainsRedirectsDataAvailable: false
  },
  updateMask: '',
  validateOnly: false
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/:+registration:configureDnsSettings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:configureDnsSettings',
  headers: {'content-type': 'application/json'},
  data: {
    dnsSettings: {
      customDns: {
        dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
        nameServers: []
      },
      glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
      googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
      googleDomainsRedirectsDataAvailable: false
    },
    updateMask: '',
    validateOnly: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+registration:configureDnsSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"dnsSettings":{"customDns":{"dsRecords":[{"algorithm":"","digest":"","digestType":"","keyTag":0}],"nameServers":[]},"glueRecords":[{"hostName":"","ipv4Addresses":[],"ipv6Addresses":[]}],"googleDomainsDns":{"dsRecords":[{}],"dsState":"","nameServers":[]},"googleDomainsRedirectsDataAvailable":false},"updateMask":"","validateOnly":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/:+registration:configureDnsSettings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "dnsSettings": {\n    "customDns": {\n      "dsRecords": [\n        {\n          "algorithm": "",\n          "digest": "",\n          "digestType": "",\n          "keyTag": 0\n        }\n      ],\n      "nameServers": []\n    },\n    "glueRecords": [\n      {\n        "hostName": "",\n        "ipv4Addresses": [],\n        "ipv6Addresses": []\n      }\n    ],\n    "googleDomainsDns": {\n      "dsRecords": [\n        {}\n      ],\n      "dsState": "",\n      "nameServers": []\n    },\n    "googleDomainsRedirectsDataAvailable": false\n  },\n  "updateMask": "",\n  "validateOnly": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:configureDnsSettings")
  .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/v1/:+registration:configureDnsSettings',
  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({
  dnsSettings: {
    customDns: {
      dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
      nameServers: []
    },
    glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
    googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
    googleDomainsRedirectsDataAvailable: false
  },
  updateMask: '',
  validateOnly: false
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:configureDnsSettings',
  headers: {'content-type': 'application/json'},
  body: {
    dnsSettings: {
      customDns: {
        dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
        nameServers: []
      },
      glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
      googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
      googleDomainsRedirectsDataAvailable: false
    },
    updateMask: '',
    validateOnly: false
  },
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/:+registration:configureDnsSettings');

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

req.type('json');
req.send({
  dnsSettings: {
    customDns: {
      dsRecords: [
        {
          algorithm: '',
          digest: '',
          digestType: '',
          keyTag: 0
        }
      ],
      nameServers: []
    },
    glueRecords: [
      {
        hostName: '',
        ipv4Addresses: [],
        ipv6Addresses: []
      }
    ],
    googleDomainsDns: {
      dsRecords: [
        {}
      ],
      dsState: '',
      nameServers: []
    },
    googleDomainsRedirectsDataAvailable: false
  },
  updateMask: '',
  validateOnly: false
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:configureDnsSettings',
  headers: {'content-type': 'application/json'},
  data: {
    dnsSettings: {
      customDns: {
        dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
        nameServers: []
      },
      glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
      googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
      googleDomainsRedirectsDataAvailable: false
    },
    updateMask: '',
    validateOnly: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+registration:configureDnsSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"dnsSettings":{"customDns":{"dsRecords":[{"algorithm":"","digest":"","digestType":"","keyTag":0}],"nameServers":[]},"glueRecords":[{"hostName":"","ipv4Addresses":[],"ipv6Addresses":[]}],"googleDomainsDns":{"dsRecords":[{}],"dsState":"","nameServers":[]},"googleDomainsRedirectsDataAvailable":false},"updateMask":"","validateOnly":false}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dnsSettings": @{ @"customDns": @{ @"dsRecords": @[ @{ @"algorithm": @"", @"digest": @"", @"digestType": @"", @"keyTag": @0 } ], @"nameServers": @[  ] }, @"glueRecords": @[ @{ @"hostName": @"", @"ipv4Addresses": @[  ], @"ipv6Addresses": @[  ] } ], @"googleDomainsDns": @{ @"dsRecords": @[ @{  } ], @"dsState": @"", @"nameServers": @[  ] }, @"googleDomainsRedirectsDataAvailable": @NO },
                              @"updateMask": @"",
                              @"validateOnly": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:+registration:configureDnsSettings"]
                                                       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}}/v1/:+registration:configureDnsSettings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+registration:configureDnsSettings",
  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([
    'dnsSettings' => [
        'customDns' => [
                'dsRecords' => [
                                [
                                                                'algorithm' => '',
                                                                'digest' => '',
                                                                'digestType' => '',
                                                                'keyTag' => 0
                                ]
                ],
                'nameServers' => [
                                
                ]
        ],
        'glueRecords' => [
                [
                                'hostName' => '',
                                'ipv4Addresses' => [
                                                                
                                ],
                                'ipv6Addresses' => [
                                                                
                                ]
                ]
        ],
        'googleDomainsDns' => [
                'dsRecords' => [
                                [
                                                                
                                ]
                ],
                'dsState' => '',
                'nameServers' => [
                                
                ]
        ],
        'googleDomainsRedirectsDataAvailable' => null
    ],
    'updateMask' => '',
    'validateOnly' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/v1/:+registration:configureDnsSettings', [
  'body' => '{
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "updateMask": "",
  "validateOnly": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+registration:configureDnsSettings');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'dnsSettings' => [
    'customDns' => [
        'dsRecords' => [
                [
                                'algorithm' => '',
                                'digest' => '',
                                'digestType' => '',
                                'keyTag' => 0
                ]
        ],
        'nameServers' => [
                
        ]
    ],
    'glueRecords' => [
        [
                'hostName' => '',
                'ipv4Addresses' => [
                                
                ],
                'ipv6Addresses' => [
                                
                ]
        ]
    ],
    'googleDomainsDns' => [
        'dsRecords' => [
                [
                                
                ]
        ],
        'dsState' => '',
        'nameServers' => [
                
        ]
    ],
    'googleDomainsRedirectsDataAvailable' => null
  ],
  'updateMask' => '',
  'validateOnly' => null
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'dnsSettings' => [
    'customDns' => [
        'dsRecords' => [
                [
                                'algorithm' => '',
                                'digest' => '',
                                'digestType' => '',
                                'keyTag' => 0
                ]
        ],
        'nameServers' => [
                
        ]
    ],
    'glueRecords' => [
        [
                'hostName' => '',
                'ipv4Addresses' => [
                                
                ],
                'ipv6Addresses' => [
                                
                ]
        ]
    ],
    'googleDomainsDns' => [
        'dsRecords' => [
                [
                                
                ]
        ],
        'dsState' => '',
        'nameServers' => [
                
        ]
    ],
    'googleDomainsRedirectsDataAvailable' => null
  ],
  'updateMask' => '',
  'validateOnly' => null
]));
$request->setRequestUrl('{{baseUrl}}/v1/:+registration:configureDnsSettings');
$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}}/v1/:+registration:configureDnsSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "updateMask": "",
  "validateOnly": false
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+registration:configureDnsSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "updateMask": "",
  "validateOnly": false
}'
import http.client

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

payload = "{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"

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

conn.request("POST", "/baseUrl/v1/:+registration:configureDnsSettings", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+registration:configureDnsSettings"

payload = {
    "dnsSettings": {
        "customDns": {
            "dsRecords": [
                {
                    "algorithm": "",
                    "digest": "",
                    "digestType": "",
                    "keyTag": 0
                }
            ],
            "nameServers": []
        },
        "glueRecords": [
            {
                "hostName": "",
                "ipv4Addresses": [],
                "ipv6Addresses": []
            }
        ],
        "googleDomainsDns": {
            "dsRecords": [{}],
            "dsState": "",
            "nameServers": []
        },
        "googleDomainsRedirectsDataAvailable": False
    },
    "updateMask": "",
    "validateOnly": False
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+registration:configureDnsSettings"

payload <- "{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+registration:configureDnsSettings")

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  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/v1/:+registration:configureDnsSettings') do |req|
  req.body = "{\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"updateMask\": \"\",\n  \"validateOnly\": false\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+registration:configureDnsSettings";

    let payload = json!({
        "dnsSettings": json!({
            "customDns": json!({
                "dsRecords": (
                    json!({
                        "algorithm": "",
                        "digest": "",
                        "digestType": "",
                        "keyTag": 0
                    })
                ),
                "nameServers": ()
            }),
            "glueRecords": (
                json!({
                    "hostName": "",
                    "ipv4Addresses": (),
                    "ipv6Addresses": ()
                })
            ),
            "googleDomainsDns": json!({
                "dsRecords": (json!({})),
                "dsState": "",
                "nameServers": ()
            }),
            "googleDomainsRedirectsDataAvailable": false
        }),
        "updateMask": "",
        "validateOnly": false
    });

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

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

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

    dbg!(results);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+registration:configureDnsSettings' \
  --header 'content-type: application/json' \
  --data '{
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "updateMask": "",
  "validateOnly": false
}'
echo '{
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "updateMask": "",
  "validateOnly": false
}' |  \
  http POST '{{baseUrl}}/v1/:+registration:configureDnsSettings' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "dnsSettings": {\n    "customDns": {\n      "dsRecords": [\n        {\n          "algorithm": "",\n          "digest": "",\n          "digestType": "",\n          "keyTag": 0\n        }\n      ],\n      "nameServers": []\n    },\n    "glueRecords": [\n      {\n        "hostName": "",\n        "ipv4Addresses": [],\n        "ipv6Addresses": []\n      }\n    ],\n    "googleDomainsDns": {\n      "dsRecords": [\n        {}\n      ],\n      "dsState": "",\n      "nameServers": []\n    },\n    "googleDomainsRedirectsDataAvailable": false\n  },\n  "updateMask": "",\n  "validateOnly": false\n}' \
  --output-document \
  - '{{baseUrl}}/v1/:+registration:configureDnsSettings'
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "dnsSettings": [
    "customDns": [
      "dsRecords": [
        [
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        ]
      ],
      "nameServers": []
    ],
    "glueRecords": [
      [
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      ]
    ],
    "googleDomainsDns": [
      "dsRecords": [[]],
      "dsState": "",
      "nameServers": []
    ],
    "googleDomainsRedirectsDataAvailable": false
  ],
  "updateMask": "",
  "validateOnly": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+registration:configureDnsSettings")! 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()
POST domains.projects.locations.registrations.configureManagementSettings
{{baseUrl}}/v1/:+registration:configureManagementSettings
QUERY PARAMS

registration
BODY json

{
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "updateMask": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+registration:configureManagementSettings");

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  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/:+registration:configureManagementSettings" {:content-type :json
                                                                                          :form-params {:managementSettings {:effectiveTransferLockState ""
                                                                                                                             :preferredRenewalMethod ""
                                                                                                                             :renewalMethod ""
                                                                                                                             :transferLockState ""}
                                                                                                        :updateMask ""}})
require "http/client"

url = "{{baseUrl}}/v1/:+registration:configureManagementSettings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\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}}/v1/:+registration:configureManagementSettings"),
    Content = new StringContent("{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\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}}/v1/:+registration:configureManagementSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+registration:configureManagementSettings"

	payload := strings.NewReader("{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\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/v1/:+registration:configureManagementSettings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 178

{
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "updateMask": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:+registration:configureManagementSettings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+registration:configureManagementSettings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\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  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:configureManagementSettings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+registration:configureManagementSettings")
  .header("content-type", "application/json")
  .body("{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  managementSettings: {
    effectiveTransferLockState: '',
    preferredRenewalMethod: '',
    renewalMethod: '',
    transferLockState: ''
  },
  updateMask: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/:+registration:configureManagementSettings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:configureManagementSettings',
  headers: {'content-type': 'application/json'},
  data: {
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    updateMask: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+registration:configureManagementSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"managementSettings":{"effectiveTransferLockState":"","preferredRenewalMethod":"","renewalMethod":"","transferLockState":""},"updateMask":""}'
};

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}}/v1/:+registration:configureManagementSettings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "managementSettings": {\n    "effectiveTransferLockState": "",\n    "preferredRenewalMethod": "",\n    "renewalMethod": "",\n    "transferLockState": ""\n  },\n  "updateMask": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:configureManagementSettings")
  .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/v1/:+registration:configureManagementSettings',
  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({
  managementSettings: {
    effectiveTransferLockState: '',
    preferredRenewalMethod: '',
    renewalMethod: '',
    transferLockState: ''
  },
  updateMask: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:configureManagementSettings',
  headers: {'content-type': 'application/json'},
  body: {
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    updateMask: ''
  },
  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}}/v1/:+registration:configureManagementSettings');

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

req.type('json');
req.send({
  managementSettings: {
    effectiveTransferLockState: '',
    preferredRenewalMethod: '',
    renewalMethod: '',
    transferLockState: ''
  },
  updateMask: ''
});

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}}/v1/:+registration:configureManagementSettings',
  headers: {'content-type': 'application/json'},
  data: {
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    updateMask: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+registration:configureManagementSettings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"managementSettings":{"effectiveTransferLockState":"","preferredRenewalMethod":"","renewalMethod":"","transferLockState":""},"updateMask":""}'
};

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 = @{ @"managementSettings": @{ @"effectiveTransferLockState": @"", @"preferredRenewalMethod": @"", @"renewalMethod": @"", @"transferLockState": @"" },
                              @"updateMask": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:+registration:configureManagementSettings"]
                                                       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}}/v1/:+registration:configureManagementSettings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+registration:configureManagementSettings",
  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([
    'managementSettings' => [
        'effectiveTransferLockState' => '',
        'preferredRenewalMethod' => '',
        'renewalMethod' => '',
        'transferLockState' => ''
    ],
    'updateMask' => ''
  ]),
  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}}/v1/:+registration:configureManagementSettings', [
  'body' => '{
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "updateMask": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+registration:configureManagementSettings');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'managementSettings' => [
    'effectiveTransferLockState' => '',
    'preferredRenewalMethod' => '',
    'renewalMethod' => '',
    'transferLockState' => ''
  ],
  'updateMask' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'managementSettings' => [
    'effectiveTransferLockState' => '',
    'preferredRenewalMethod' => '',
    'renewalMethod' => '',
    'transferLockState' => ''
  ],
  'updateMask' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/:+registration:configureManagementSettings');
$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}}/v1/:+registration:configureManagementSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "updateMask": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+registration:configureManagementSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "updateMask": ""
}'
import http.client

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

payload = "{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1/:+registration:configureManagementSettings", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+registration:configureManagementSettings"

payload = {
    "managementSettings": {
        "effectiveTransferLockState": "",
        "preferredRenewalMethod": "",
        "renewalMethod": "",
        "transferLockState": ""
    },
    "updateMask": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+registration:configureManagementSettings"

payload <- "{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\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}}/v1/:+registration:configureManagementSettings")

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  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\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/v1/:+registration:configureManagementSettings') do |req|
  req.body = "{\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"updateMask\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+registration:configureManagementSettings";

    let payload = json!({
        "managementSettings": json!({
            "effectiveTransferLockState": "",
            "preferredRenewalMethod": "",
            "renewalMethod": "",
            "transferLockState": ""
        }),
        "updateMask": ""
    });

    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);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+registration:configureManagementSettings' \
  --header 'content-type: application/json' \
  --data '{
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "updateMask": ""
}'
echo '{
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "updateMask": ""
}' |  \
  http POST '{{baseUrl}}/v1/:+registration:configureManagementSettings' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "managementSettings": {\n    "effectiveTransferLockState": "",\n    "preferredRenewalMethod": "",\n    "renewalMethod": "",\n    "transferLockState": ""\n  },\n  "updateMask": ""\n}' \
  --output-document \
  - '{{baseUrl}}/v1/:+registration:configureManagementSettings'
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "managementSettings": [
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  ],
  "updateMask": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+registration:configureManagementSettings")! 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()
DELETE domains.projects.locations.registrations.delete
{{baseUrl}}/v1/:+name
QUERY PARAMS

name
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+name");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/:+name")
require "http/client"

url = "{{baseUrl}}/v1/:+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}}/v1/:+name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+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/v1/:+name HTTP/1.1
Host: example.com

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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+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}}/v1/:+name")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/v1/:+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}}/v1/:+name');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/:+name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+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}}/v1/:+name',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+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/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+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}}/v1/:+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}}/v1/:+name" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+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}}/v1/:+name');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+name');
$request->setMethod(HTTP_METH_DELETE);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+name' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+name' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/v1/:+name")

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

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

url = "{{baseUrl}}/v1/:+name"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+name"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+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/v1/:+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}}/v1/:+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);
}
curl --request DELETE \
  --url '{{baseUrl}}/v1/:+name'
http DELETE '{{baseUrl}}/v1/:+name'
wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/v1/:+name'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+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()
POST domains.projects.locations.registrations.export
{{baseUrl}}/v1/:+name:export
QUERY PARAMS

name
BODY json

{}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+name:export");

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}}/v1/:+name:export" {:content-type :json})
require "http/client"

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

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

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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+name:export")
  .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}}/v1/:+name:export');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+name:export';
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}}/v1/:+name:export',
  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}}/v1/:+name:export")
  .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/v1/:+name:export',
  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}}/v1/:+name:export',
  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}}/v1/:+name:export');

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

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+name:export');
$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}}/v1/:+name:export');
$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}}/v1/:+name:export' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+name:export' -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/v1/:+name:export", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+name:export"

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

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+name:export"

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}}/v1/:+name:export")

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/v1/:+name:export') 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}}/v1/:+name:export";

    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);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+name:export' \
  --header 'content-type: application/json' \
  --data '{}'
echo '{}' |  \
  http POST '{{baseUrl}}/v1/:+name:export' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - '{{baseUrl}}/v1/:+name:export'
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}}/v1/:+name:export")! 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()
GET domains.projects.locations.registrations.get
{{baseUrl}}/v1/:+name
QUERY PARAMS

name
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+name");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+name")
require "http/client"

url = "{{baseUrl}}/v1/:+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}}/v1/:+name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+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/v1/:+name HTTP/1.1
Host: example.com

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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+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}}/v1/:+name');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/:+name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+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}}/v1/:+name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

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

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+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}}/v1/:+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}}/v1/:+name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+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}}/v1/:+name');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+name');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+name' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+name' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+name")

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

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

url = "{{baseUrl}}/v1/:+name"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+name"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+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/v1/:+name') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+name'
http GET '{{baseUrl}}/v1/:+name'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+name'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+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()
GET domains.projects.locations.registrations.getIamPolicy
{{baseUrl}}/v1/:+resource:getIamPolicy
QUERY PARAMS

resource
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+resource:getIamPolicy");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+resource:getIamPolicy")
require "http/client"

url = "{{baseUrl}}/v1/:+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}}/v1/:+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}}/v1/:+resource:getIamPolicy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+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/v1/:+resource:getIamPolicy HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/:+resource:getIamPolicy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+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}}/v1/:+resource:getIamPolicy")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+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}}/v1/:+resource:getIamPolicy');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/:+resource:getIamPolicy'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+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}}/v1/:+resource:getIamPolicy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+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/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+resource:getIamPolicy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+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}}/v1/:+resource:getIamPolicy');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+resource:getIamPolicy');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+resource:getIamPolicy');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+resource:getIamPolicy' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+resource:getIamPolicy' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+resource:getIamPolicy")

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

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

url = "{{baseUrl}}/v1/:+resource:getIamPolicy"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+resource:getIamPolicy"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+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/v1/:+resource:getIamPolicy') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+resource:getIamPolicy";

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+resource:getIamPolicy'
http GET '{{baseUrl}}/v1/:+resource:getIamPolicy'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+resource:getIamPolicy'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+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()
POST domains.projects.locations.registrations.import
{{baseUrl}}/v1/:+parent/registrations:import
QUERY PARAMS

parent
BODY json

{
  "domainName": "",
  "labels": {}
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+parent/registrations:import");

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  \"domainName\": \"\",\n  \"labels\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/:+parent/registrations:import" {:content-type :json
                                                                             :form-params {:domainName ""
                                                                                           :labels {}}})
require "http/client"

url = "{{baseUrl}}/v1/:+parent/registrations:import"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"domainName\": \"\",\n  \"labels\": {}\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}}/v1/:+parent/registrations:import"),
    Content = new StringContent("{\n  \"domainName\": \"\",\n  \"labels\": {}\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}}/v1/:+parent/registrations:import");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domainName\": \"\",\n  \"labels\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+parent/registrations:import"

	payload := strings.NewReader("{\n  \"domainName\": \"\",\n  \"labels\": {}\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/v1/:+parent/registrations:import HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 38

{
  "domainName": "",
  "labels": {}
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:+parent/registrations:import")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domainName\": \"\",\n  \"labels\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+parent/registrations:import"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domainName\": \"\",\n  \"labels\": {}\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  \"domainName\": \"\",\n  \"labels\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:+parent/registrations:import")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+parent/registrations:import")
  .header("content-type", "application/json")
  .body("{\n  \"domainName\": \"\",\n  \"labels\": {}\n}")
  .asString();
const data = JSON.stringify({
  domainName: '',
  labels: {}
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/:+parent/registrations:import');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+parent/registrations:import',
  headers: {'content-type': 'application/json'},
  data: {domainName: '', labels: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+parent/registrations:import';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"domainName":"","labels":{}}'
};

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}}/v1/:+parent/registrations:import',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domainName": "",\n  "labels": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domainName\": \"\",\n  \"labels\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+parent/registrations:import")
  .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/v1/:+parent/registrations:import',
  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({domainName: '', labels: {}}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+parent/registrations:import',
  headers: {'content-type': 'application/json'},
  body: {domainName: '', labels: {}},
  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}}/v1/:+parent/registrations:import');

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

req.type('json');
req.send({
  domainName: '',
  labels: {}
});

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}}/v1/:+parent/registrations:import',
  headers: {'content-type': 'application/json'},
  data: {domainName: '', labels: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+parent/registrations:import';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"domainName":"","labels":{}}'
};

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 = @{ @"domainName": @"",
                              @"labels": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:+parent/registrations:import"]
                                                       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}}/v1/:+parent/registrations:import" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"domainName\": \"\",\n  \"labels\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+parent/registrations:import",
  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([
    'domainName' => '',
    'labels' => [
        
    ]
  ]),
  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}}/v1/:+parent/registrations:import', [
  'body' => '{
  "domainName": "",
  "labels": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+parent/registrations:import');
$request->setMethod(HTTP_METH_POST);

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

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'domainName' => '',
  'labels' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/:+parent/registrations:import');
$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}}/v1/:+parent/registrations:import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domainName": "",
  "labels": {}
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+parent/registrations:import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domainName": "",
  "labels": {}
}'
import http.client

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

payload = "{\n  \"domainName\": \"\",\n  \"labels\": {}\n}"

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

conn.request("POST", "/baseUrl/v1/:+parent/registrations:import", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+parent/registrations:import"

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

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+parent/registrations:import"

payload <- "{\n  \"domainName\": \"\",\n  \"labels\": {}\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}}/v1/:+parent/registrations:import")

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  \"domainName\": \"\",\n  \"labels\": {}\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/v1/:+parent/registrations:import') do |req|
  req.body = "{\n  \"domainName\": \"\",\n  \"labels\": {}\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+parent/registrations:import";

    let payload = json!({
        "domainName": "",
        "labels": 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);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+parent/registrations:import' \
  --header 'content-type: application/json' \
  --data '{
  "domainName": "",
  "labels": {}
}'
echo '{
  "domainName": "",
  "labels": {}
}' |  \
  http POST '{{baseUrl}}/v1/:+parent/registrations:import' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "domainName": "",\n  "labels": {}\n}' \
  --output-document \
  - '{{baseUrl}}/v1/:+parent/registrations:import'
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+parent/registrations:import")! 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()
POST domains.projects.locations.registrations.initiatePushTransfer
{{baseUrl}}/v1/:+registration:initiatePushTransfer
QUERY PARAMS

registration
BODY json

{
  "tag": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+registration:initiatePushTransfer");

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

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/:+registration:initiatePushTransfer" {:content-type :json
                                                                                   :form-params {:tag ""}})
require "http/client"

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

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

func main() {

	url := "{{baseUrl}}/v1/:+registration:initiatePushTransfer"

	payload := strings.NewReader("{\n  \"tag\": \"\"\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/v1/:+registration:initiatePushTransfer HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 15

{
  "tag": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:+registration:initiatePushTransfer")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tag\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+registration:initiatePushTransfer")
  .header("content-type", "application/json")
  .body("{\n  \"tag\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  tag: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/:+registration:initiatePushTransfer');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:initiatePushTransfer',
  headers: {'content-type': 'application/json'},
  data: {tag: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+registration:initiatePushTransfer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tag":""}'
};

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}}/v1/:+registration:initiatePushTransfer',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tag": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tag\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:initiatePushTransfer")
  .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/v1/:+registration:initiatePushTransfer',
  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({tag: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:initiatePushTransfer',
  headers: {'content-type': 'application/json'},
  body: {tag: ''},
  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}}/v1/:+registration:initiatePushTransfer');

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

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

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}}/v1/:+registration:initiatePushTransfer',
  headers: {'content-type': 'application/json'},
  data: {tag: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+registration:initiatePushTransfer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tag":""}'
};

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

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

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

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+registration:initiatePushTransfer",
  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([
    'tag' => ''
  ]),
  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}}/v1/:+registration:initiatePushTransfer', [
  'body' => '{
  "tag": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+registration:initiatePushTransfer');
$request->setMethod(HTTP_METH_POST);

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

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'tag' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/:+registration:initiatePushTransfer');
$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}}/v1/:+registration:initiatePushTransfer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tag": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+registration:initiatePushTransfer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tag": ""
}'
import http.client

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

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

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

conn.request("POST", "/baseUrl/v1/:+registration:initiatePushTransfer", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+registration:initiatePushTransfer"

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

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+registration:initiatePushTransfer"

payload <- "{\n  \"tag\": \"\"\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}}/v1/:+registration:initiatePushTransfer")

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  \"tag\": \"\"\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/v1/:+registration:initiatePushTransfer') do |req|
  req.body = "{\n  \"tag\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+registration:initiatePushTransfer";

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

    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);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+registration:initiatePushTransfer' \
  --header 'content-type: application/json' \
  --data '{
  "tag": ""
}'
echo '{
  "tag": ""
}' |  \
  http POST '{{baseUrl}}/v1/:+registration:initiatePushTransfer' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tag": ""\n}' \
  --output-document \
  - '{{baseUrl}}/v1/:+registration:initiatePushTransfer'
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+registration:initiatePushTransfer")! 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()
GET domains.projects.locations.registrations.list
{{baseUrl}}/v1/:+parent/registrations
QUERY PARAMS

parent
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+parent/registrations");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+parent/registrations")
require "http/client"

url = "{{baseUrl}}/v1/:+parent/registrations"

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}}/v1/:+parent/registrations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+parent/registrations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+parent/registrations"

	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/v1/:+parent/registrations HTTP/1.1
Host: example.com

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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+parent/registrations")
  .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}}/v1/:+parent/registrations');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/:+parent/registrations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+parent/registrations';
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}}/v1/:+parent/registrations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+parent/registrations")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/:+parent/registrations');

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}}/v1/:+parent/registrations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+parent/registrations",
  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}}/v1/:+parent/registrations');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+parent/registrations');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+parent/registrations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+parent/registrations' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+parent/registrations' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+parent/registrations")

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

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

url = "{{baseUrl}}/v1/:+parent/registrations"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+parent/registrations"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+parent/registrations")

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/v1/:+parent/registrations') do |req|
end

puts response.status
puts response.body
use reqwest;

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

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+parent/registrations'
http GET '{{baseUrl}}/v1/:+parent/registrations'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+parent/registrations'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+parent/registrations")! 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()
PATCH domains.projects.locations.registrations.patch
{{baseUrl}}/v1/:+name
QUERY PARAMS

name
BODY json

{
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "createTime": "",
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "domainName": "",
  "domainProperties": [],
  "expireTime": "",
  "issues": [],
  "labels": {},
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "name": "",
  "pendingContactSettings": {},
  "registerFailureReason": "",
  "state": "",
  "supportedPrivacy": [],
  "transferFailureReason": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+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  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/v1/:+name" {:content-type :json
                                                       :form-params {:contactSettings {:adminContact {:email ""
                                                                                                      :faxNumber ""
                                                                                                      :phoneNumber ""
                                                                                                      :postalAddress {:addressLines []
                                                                                                                      :administrativeArea ""
                                                                                                                      :languageCode ""
                                                                                                                      :locality ""
                                                                                                                      :organization ""
                                                                                                                      :postalCode ""
                                                                                                                      :recipients []
                                                                                                                      :regionCode ""
                                                                                                                      :revision 0
                                                                                                                      :sortingCode ""
                                                                                                                      :sublocality ""}}
                                                                                       :privacy ""
                                                                                       :registrantContact {}
                                                                                       :technicalContact {}}
                                                                     :createTime ""
                                                                     :dnsSettings {:customDns {:dsRecords [{:algorithm ""
                                                                                                            :digest ""
                                                                                                            :digestType ""
                                                                                                            :keyTag 0}]
                                                                                               :nameServers []}
                                                                                   :glueRecords [{:hostName ""
                                                                                                  :ipv4Addresses []
                                                                                                  :ipv6Addresses []}]
                                                                                   :googleDomainsDns {:dsRecords [{}]
                                                                                                      :dsState ""
                                                                                                      :nameServers []}
                                                                                   :googleDomainsRedirectsDataAvailable false}
                                                                     :domainName ""
                                                                     :domainProperties []
                                                                     :expireTime ""
                                                                     :issues []
                                                                     :labels {}
                                                                     :managementSettings {:effectiveTransferLockState ""
                                                                                          :preferredRenewalMethod ""
                                                                                          :renewalMethod ""
                                                                                          :transferLockState ""}
                                                                     :name ""
                                                                     :pendingContactSettings {}
                                                                     :registerFailureReason ""
                                                                     :state ""
                                                                     :supportedPrivacy []
                                                                     :transferFailureReason ""}})
require "http/client"

url = "{{baseUrl}}/v1/:+name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\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}}/v1/:+name"),
    Content = new StringContent("{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\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}}/v1/:+name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+name"

	payload := strings.NewReader("{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\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/v1/:+name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1471

{
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "createTime": "",
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "domainName": "",
  "domainProperties": [],
  "expireTime": "",
  "issues": [],
  "labels": {},
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "name": "",
  "pendingContactSettings": {},
  "registerFailureReason": "",
  "state": "",
  "supportedPrivacy": [],
  "transferFailureReason": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1/:+name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+name"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\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  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:+name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.patch("{{baseUrl}}/v1/:+name")
  .header("content-type", "application/json")
  .body("{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  contactSettings: {
    adminContact: {
      email: '',
      faxNumber: '',
      phoneNumber: '',
      postalAddress: {
        addressLines: [],
        administrativeArea: '',
        languageCode: '',
        locality: '',
        organization: '',
        postalCode: '',
        recipients: [],
        regionCode: '',
        revision: 0,
        sortingCode: '',
        sublocality: ''
      }
    },
    privacy: '',
    registrantContact: {},
    technicalContact: {}
  },
  createTime: '',
  dnsSettings: {
    customDns: {
      dsRecords: [
        {
          algorithm: '',
          digest: '',
          digestType: '',
          keyTag: 0
        }
      ],
      nameServers: []
    },
    glueRecords: [
      {
        hostName: '',
        ipv4Addresses: [],
        ipv6Addresses: []
      }
    ],
    googleDomainsDns: {
      dsRecords: [
        {}
      ],
      dsState: '',
      nameServers: []
    },
    googleDomainsRedirectsDataAvailable: false
  },
  domainName: '',
  domainProperties: [],
  expireTime: '',
  issues: [],
  labels: {},
  managementSettings: {
    effectiveTransferLockState: '',
    preferredRenewalMethod: '',
    renewalMethod: '',
    transferLockState: ''
  },
  name: '',
  pendingContactSettings: {},
  registerFailureReason: '',
  state: '',
  supportedPrivacy: [],
  transferFailureReason: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v1/:+name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1/:+name',
  headers: {'content-type': 'application/json'},
  data: {
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    createTime: '',
    dnsSettings: {
      customDns: {
        dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
        nameServers: []
      },
      glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
      googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
      googleDomainsRedirectsDataAvailable: false
    },
    domainName: '',
    domainProperties: [],
    expireTime: '',
    issues: [],
    labels: {},
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    name: '',
    pendingContactSettings: {},
    registerFailureReason: '',
    state: '',
    supportedPrivacy: [],
    transferFailureReason: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"contactSettings":{"adminContact":{"email":"","faxNumber":"","phoneNumber":"","postalAddress":{"addressLines":[],"administrativeArea":"","languageCode":"","locality":"","organization":"","postalCode":"","recipients":[],"regionCode":"","revision":0,"sortingCode":"","sublocality":""}},"privacy":"","registrantContact":{},"technicalContact":{}},"createTime":"","dnsSettings":{"customDns":{"dsRecords":[{"algorithm":"","digest":"","digestType":"","keyTag":0}],"nameServers":[]},"glueRecords":[{"hostName":"","ipv4Addresses":[],"ipv6Addresses":[]}],"googleDomainsDns":{"dsRecords":[{}],"dsState":"","nameServers":[]},"googleDomainsRedirectsDataAvailable":false},"domainName":"","domainProperties":[],"expireTime":"","issues":[],"labels":{},"managementSettings":{"effectiveTransferLockState":"","preferredRenewalMethod":"","renewalMethod":"","transferLockState":""},"name":"","pendingContactSettings":{},"registerFailureReason":"","state":"","supportedPrivacy":[],"transferFailureReason":""}'
};

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}}/v1/:+name',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "contactSettings": {\n    "adminContact": {\n      "email": "",\n      "faxNumber": "",\n      "phoneNumber": "",\n      "postalAddress": {\n        "addressLines": [],\n        "administrativeArea": "",\n        "languageCode": "",\n        "locality": "",\n        "organization": "",\n        "postalCode": "",\n        "recipients": [],\n        "regionCode": "",\n        "revision": 0,\n        "sortingCode": "",\n        "sublocality": ""\n      }\n    },\n    "privacy": "",\n    "registrantContact": {},\n    "technicalContact": {}\n  },\n  "createTime": "",\n  "dnsSettings": {\n    "customDns": {\n      "dsRecords": [\n        {\n          "algorithm": "",\n          "digest": "",\n          "digestType": "",\n          "keyTag": 0\n        }\n      ],\n      "nameServers": []\n    },\n    "glueRecords": [\n      {\n        "hostName": "",\n        "ipv4Addresses": [],\n        "ipv6Addresses": []\n      }\n    ],\n    "googleDomainsDns": {\n      "dsRecords": [\n        {}\n      ],\n      "dsState": "",\n      "nameServers": []\n    },\n    "googleDomainsRedirectsDataAvailable": false\n  },\n  "domainName": "",\n  "domainProperties": [],\n  "expireTime": "",\n  "issues": [],\n  "labels": {},\n  "managementSettings": {\n    "effectiveTransferLockState": "",\n    "preferredRenewalMethod": "",\n    "renewalMethod": "",\n    "transferLockState": ""\n  },\n  "name": "",\n  "pendingContactSettings": {},\n  "registerFailureReason": "",\n  "state": "",\n  "supportedPrivacy": [],\n  "transferFailureReason": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+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/v1/:+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({
  contactSettings: {
    adminContact: {
      email: '',
      faxNumber: '',
      phoneNumber: '',
      postalAddress: {
        addressLines: [],
        administrativeArea: '',
        languageCode: '',
        locality: '',
        organization: '',
        postalCode: '',
        recipients: [],
        regionCode: '',
        revision: 0,
        sortingCode: '',
        sublocality: ''
      }
    },
    privacy: '',
    registrantContact: {},
    technicalContact: {}
  },
  createTime: '',
  dnsSettings: {
    customDns: {
      dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
      nameServers: []
    },
    glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
    googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
    googleDomainsRedirectsDataAvailable: false
  },
  domainName: '',
  domainProperties: [],
  expireTime: '',
  issues: [],
  labels: {},
  managementSettings: {
    effectiveTransferLockState: '',
    preferredRenewalMethod: '',
    renewalMethod: '',
    transferLockState: ''
  },
  name: '',
  pendingContactSettings: {},
  registerFailureReason: '',
  state: '',
  supportedPrivacy: [],
  transferFailureReason: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1/:+name',
  headers: {'content-type': 'application/json'},
  body: {
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    createTime: '',
    dnsSettings: {
      customDns: {
        dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
        nameServers: []
      },
      glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
      googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
      googleDomainsRedirectsDataAvailable: false
    },
    domainName: '',
    domainProperties: [],
    expireTime: '',
    issues: [],
    labels: {},
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    name: '',
    pendingContactSettings: {},
    registerFailureReason: '',
    state: '',
    supportedPrivacy: [],
    transferFailureReason: ''
  },
  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}}/v1/:+name');

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

req.type('json');
req.send({
  contactSettings: {
    adminContact: {
      email: '',
      faxNumber: '',
      phoneNumber: '',
      postalAddress: {
        addressLines: [],
        administrativeArea: '',
        languageCode: '',
        locality: '',
        organization: '',
        postalCode: '',
        recipients: [],
        regionCode: '',
        revision: 0,
        sortingCode: '',
        sublocality: ''
      }
    },
    privacy: '',
    registrantContact: {},
    technicalContact: {}
  },
  createTime: '',
  dnsSettings: {
    customDns: {
      dsRecords: [
        {
          algorithm: '',
          digest: '',
          digestType: '',
          keyTag: 0
        }
      ],
      nameServers: []
    },
    glueRecords: [
      {
        hostName: '',
        ipv4Addresses: [],
        ipv6Addresses: []
      }
    ],
    googleDomainsDns: {
      dsRecords: [
        {}
      ],
      dsState: '',
      nameServers: []
    },
    googleDomainsRedirectsDataAvailable: false
  },
  domainName: '',
  domainProperties: [],
  expireTime: '',
  issues: [],
  labels: {},
  managementSettings: {
    effectiveTransferLockState: '',
    preferredRenewalMethod: '',
    renewalMethod: '',
    transferLockState: ''
  },
  name: '',
  pendingContactSettings: {},
  registerFailureReason: '',
  state: '',
  supportedPrivacy: [],
  transferFailureReason: ''
});

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}}/v1/:+name',
  headers: {'content-type': 'application/json'},
  data: {
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    createTime: '',
    dnsSettings: {
      customDns: {
        dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
        nameServers: []
      },
      glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
      googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
      googleDomainsRedirectsDataAvailable: false
    },
    domainName: '',
    domainProperties: [],
    expireTime: '',
    issues: [],
    labels: {},
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    name: '',
    pendingContactSettings: {},
    registerFailureReason: '',
    state: '',
    supportedPrivacy: [],
    transferFailureReason: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"contactSettings":{"adminContact":{"email":"","faxNumber":"","phoneNumber":"","postalAddress":{"addressLines":[],"administrativeArea":"","languageCode":"","locality":"","organization":"","postalCode":"","recipients":[],"regionCode":"","revision":0,"sortingCode":"","sublocality":""}},"privacy":"","registrantContact":{},"technicalContact":{}},"createTime":"","dnsSettings":{"customDns":{"dsRecords":[{"algorithm":"","digest":"","digestType":"","keyTag":0}],"nameServers":[]},"glueRecords":[{"hostName":"","ipv4Addresses":[],"ipv6Addresses":[]}],"googleDomainsDns":{"dsRecords":[{}],"dsState":"","nameServers":[]},"googleDomainsRedirectsDataAvailable":false},"domainName":"","domainProperties":[],"expireTime":"","issues":[],"labels":{},"managementSettings":{"effectiveTransferLockState":"","preferredRenewalMethod":"","renewalMethod":"","transferLockState":""},"name":"","pendingContactSettings":{},"registerFailureReason":"","state":"","supportedPrivacy":[],"transferFailureReason":""}'
};

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 = @{ @"contactSettings": @{ @"adminContact": @{ @"email": @"", @"faxNumber": @"", @"phoneNumber": @"", @"postalAddress": @{ @"addressLines": @[  ], @"administrativeArea": @"", @"languageCode": @"", @"locality": @"", @"organization": @"", @"postalCode": @"", @"recipients": @[  ], @"regionCode": @"", @"revision": @0, @"sortingCode": @"", @"sublocality": @"" } }, @"privacy": @"", @"registrantContact": @{  }, @"technicalContact": @{  } },
                              @"createTime": @"",
                              @"dnsSettings": @{ @"customDns": @{ @"dsRecords": @[ @{ @"algorithm": @"", @"digest": @"", @"digestType": @"", @"keyTag": @0 } ], @"nameServers": @[  ] }, @"glueRecords": @[ @{ @"hostName": @"", @"ipv4Addresses": @[  ], @"ipv6Addresses": @[  ] } ], @"googleDomainsDns": @{ @"dsRecords": @[ @{  } ], @"dsState": @"", @"nameServers": @[  ] }, @"googleDomainsRedirectsDataAvailable": @NO },
                              @"domainName": @"",
                              @"domainProperties": @[  ],
                              @"expireTime": @"",
                              @"issues": @[  ],
                              @"labels": @{  },
                              @"managementSettings": @{ @"effectiveTransferLockState": @"", @"preferredRenewalMethod": @"", @"renewalMethod": @"", @"transferLockState": @"" },
                              @"name": @"",
                              @"pendingContactSettings": @{  },
                              @"registerFailureReason": @"",
                              @"state": @"",
                              @"supportedPrivacy": @[  ],
                              @"transferFailureReason": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:+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}}/v1/:+name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+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([
    'contactSettings' => [
        'adminContact' => [
                'email' => '',
                'faxNumber' => '',
                'phoneNumber' => '',
                'postalAddress' => [
                                'addressLines' => [
                                                                
                                ],
                                'administrativeArea' => '',
                                'languageCode' => '',
                                'locality' => '',
                                'organization' => '',
                                'postalCode' => '',
                                'recipients' => [
                                                                
                                ],
                                'regionCode' => '',
                                'revision' => 0,
                                'sortingCode' => '',
                                'sublocality' => ''
                ]
        ],
        'privacy' => '',
        'registrantContact' => [
                
        ],
        'technicalContact' => [
                
        ]
    ],
    'createTime' => '',
    'dnsSettings' => [
        'customDns' => [
                'dsRecords' => [
                                [
                                                                'algorithm' => '',
                                                                'digest' => '',
                                                                'digestType' => '',
                                                                'keyTag' => 0
                                ]
                ],
                'nameServers' => [
                                
                ]
        ],
        'glueRecords' => [
                [
                                'hostName' => '',
                                'ipv4Addresses' => [
                                                                
                                ],
                                'ipv6Addresses' => [
                                                                
                                ]
                ]
        ],
        'googleDomainsDns' => [
                'dsRecords' => [
                                [
                                                                
                                ]
                ],
                'dsState' => '',
                'nameServers' => [
                                
                ]
        ],
        'googleDomainsRedirectsDataAvailable' => null
    ],
    'domainName' => '',
    'domainProperties' => [
        
    ],
    'expireTime' => '',
    'issues' => [
        
    ],
    'labels' => [
        
    ],
    'managementSettings' => [
        'effectiveTransferLockState' => '',
        'preferredRenewalMethod' => '',
        'renewalMethod' => '',
        'transferLockState' => ''
    ],
    'name' => '',
    'pendingContactSettings' => [
        
    ],
    'registerFailureReason' => '',
    'state' => '',
    'supportedPrivacy' => [
        
    ],
    'transferFailureReason' => ''
  ]),
  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}}/v1/:+name', [
  'body' => '{
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "createTime": "",
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "domainName": "",
  "domainProperties": [],
  "expireTime": "",
  "issues": [],
  "labels": {},
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "name": "",
  "pendingContactSettings": {},
  "registerFailureReason": "",
  "state": "",
  "supportedPrivacy": [],
  "transferFailureReason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+name');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'contactSettings' => [
    'adminContact' => [
        'email' => '',
        'faxNumber' => '',
        'phoneNumber' => '',
        'postalAddress' => [
                'addressLines' => [
                                
                ],
                'administrativeArea' => '',
                'languageCode' => '',
                'locality' => '',
                'organization' => '',
                'postalCode' => '',
                'recipients' => [
                                
                ],
                'regionCode' => '',
                'revision' => 0,
                'sortingCode' => '',
                'sublocality' => ''
        ]
    ],
    'privacy' => '',
    'registrantContact' => [
        
    ],
    'technicalContact' => [
        
    ]
  ],
  'createTime' => '',
  'dnsSettings' => [
    'customDns' => [
        'dsRecords' => [
                [
                                'algorithm' => '',
                                'digest' => '',
                                'digestType' => '',
                                'keyTag' => 0
                ]
        ],
        'nameServers' => [
                
        ]
    ],
    'glueRecords' => [
        [
                'hostName' => '',
                'ipv4Addresses' => [
                                
                ],
                'ipv6Addresses' => [
                                
                ]
        ]
    ],
    'googleDomainsDns' => [
        'dsRecords' => [
                [
                                
                ]
        ],
        'dsState' => '',
        'nameServers' => [
                
        ]
    ],
    'googleDomainsRedirectsDataAvailable' => null
  ],
  'domainName' => '',
  'domainProperties' => [
    
  ],
  'expireTime' => '',
  'issues' => [
    
  ],
  'labels' => [
    
  ],
  'managementSettings' => [
    'effectiveTransferLockState' => '',
    'preferredRenewalMethod' => '',
    'renewalMethod' => '',
    'transferLockState' => ''
  ],
  'name' => '',
  'pendingContactSettings' => [
    
  ],
  'registerFailureReason' => '',
  'state' => '',
  'supportedPrivacy' => [
    
  ],
  'transferFailureReason' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'contactSettings' => [
    'adminContact' => [
        'email' => '',
        'faxNumber' => '',
        'phoneNumber' => '',
        'postalAddress' => [
                'addressLines' => [
                                
                ],
                'administrativeArea' => '',
                'languageCode' => '',
                'locality' => '',
                'organization' => '',
                'postalCode' => '',
                'recipients' => [
                                
                ],
                'regionCode' => '',
                'revision' => 0,
                'sortingCode' => '',
                'sublocality' => ''
        ]
    ],
    'privacy' => '',
    'registrantContact' => [
        
    ],
    'technicalContact' => [
        
    ]
  ],
  'createTime' => '',
  'dnsSettings' => [
    'customDns' => [
        'dsRecords' => [
                [
                                'algorithm' => '',
                                'digest' => '',
                                'digestType' => '',
                                'keyTag' => 0
                ]
        ],
        'nameServers' => [
                
        ]
    ],
    'glueRecords' => [
        [
                'hostName' => '',
                'ipv4Addresses' => [
                                
                ],
                'ipv6Addresses' => [
                                
                ]
        ]
    ],
    'googleDomainsDns' => [
        'dsRecords' => [
                [
                                
                ]
        ],
        'dsState' => '',
        'nameServers' => [
                
        ]
    ],
    'googleDomainsRedirectsDataAvailable' => null
  ],
  'domainName' => '',
  'domainProperties' => [
    
  ],
  'expireTime' => '',
  'issues' => [
    
  ],
  'labels' => [
    
  ],
  'managementSettings' => [
    'effectiveTransferLockState' => '',
    'preferredRenewalMethod' => '',
    'renewalMethod' => '',
    'transferLockState' => ''
  ],
  'name' => '',
  'pendingContactSettings' => [
    
  ],
  'registerFailureReason' => '',
  'state' => '',
  'supportedPrivacy' => [
    
  ],
  'transferFailureReason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/:+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}}/v1/:+name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "createTime": "",
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "domainName": "",
  "domainProperties": [],
  "expireTime": "",
  "issues": [],
  "labels": {},
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "name": "",
  "pendingContactSettings": {},
  "registerFailureReason": "",
  "state": "",
  "supportedPrivacy": [],
  "transferFailureReason": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "createTime": "",
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "domainName": "",
  "domainProperties": [],
  "expireTime": "",
  "issues": [],
  "labels": {},
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "name": "",
  "pendingContactSettings": {},
  "registerFailureReason": "",
  "state": "",
  "supportedPrivacy": [],
  "transferFailureReason": ""
}'
import http.client

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

payload = "{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/v1/:+name", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+name"

payload = {
    "contactSettings": {
        "adminContact": {
            "email": "",
            "faxNumber": "",
            "phoneNumber": "",
            "postalAddress": {
                "addressLines": [],
                "administrativeArea": "",
                "languageCode": "",
                "locality": "",
                "organization": "",
                "postalCode": "",
                "recipients": [],
                "regionCode": "",
                "revision": 0,
                "sortingCode": "",
                "sublocality": ""
            }
        },
        "privacy": "",
        "registrantContact": {},
        "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
        "customDns": {
            "dsRecords": [
                {
                    "algorithm": "",
                    "digest": "",
                    "digestType": "",
                    "keyTag": 0
                }
            ],
            "nameServers": []
        },
        "glueRecords": [
            {
                "hostName": "",
                "ipv4Addresses": [],
                "ipv6Addresses": []
            }
        ],
        "googleDomainsDns": {
            "dsRecords": [{}],
            "dsState": "",
            "nameServers": []
        },
        "googleDomainsRedirectsDataAvailable": False
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
        "effectiveTransferLockState": "",
        "preferredRenewalMethod": "",
        "renewalMethod": "",
        "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+name"

payload <- "{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\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}}/v1/:+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  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\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/v1/:+name') do |req|
  req.body = "{\n  \"contactSettings\": {\n    \"adminContact\": {\n      \"email\": \"\",\n      \"faxNumber\": \"\",\n      \"phoneNumber\": \"\",\n      \"postalAddress\": {\n        \"addressLines\": [],\n        \"administrativeArea\": \"\",\n        \"languageCode\": \"\",\n        \"locality\": \"\",\n        \"organization\": \"\",\n        \"postalCode\": \"\",\n        \"recipients\": [],\n        \"regionCode\": \"\",\n        \"revision\": 0,\n        \"sortingCode\": \"\",\n        \"sublocality\": \"\"\n      }\n    },\n    \"privacy\": \"\",\n    \"registrantContact\": {},\n    \"technicalContact\": {}\n  },\n  \"createTime\": \"\",\n  \"dnsSettings\": {\n    \"customDns\": {\n      \"dsRecords\": [\n        {\n          \"algorithm\": \"\",\n          \"digest\": \"\",\n          \"digestType\": \"\",\n          \"keyTag\": 0\n        }\n      ],\n      \"nameServers\": []\n    },\n    \"glueRecords\": [\n      {\n        \"hostName\": \"\",\n        \"ipv4Addresses\": [],\n        \"ipv6Addresses\": []\n      }\n    ],\n    \"googleDomainsDns\": {\n      \"dsRecords\": [\n        {}\n      ],\n      \"dsState\": \"\",\n      \"nameServers\": []\n    },\n    \"googleDomainsRedirectsDataAvailable\": false\n  },\n  \"domainName\": \"\",\n  \"domainProperties\": [],\n  \"expireTime\": \"\",\n  \"issues\": [],\n  \"labels\": {},\n  \"managementSettings\": {\n    \"effectiveTransferLockState\": \"\",\n    \"preferredRenewalMethod\": \"\",\n    \"renewalMethod\": \"\",\n    \"transferLockState\": \"\"\n  },\n  \"name\": \"\",\n  \"pendingContactSettings\": {},\n  \"registerFailureReason\": \"\",\n  \"state\": \"\",\n  \"supportedPrivacy\": [],\n  \"transferFailureReason\": \"\"\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}}/v1/:+name";

    let payload = json!({
        "contactSettings": json!({
            "adminContact": json!({
                "email": "",
                "faxNumber": "",
                "phoneNumber": "",
                "postalAddress": json!({
                    "addressLines": (),
                    "administrativeArea": "",
                    "languageCode": "",
                    "locality": "",
                    "organization": "",
                    "postalCode": "",
                    "recipients": (),
                    "regionCode": "",
                    "revision": 0,
                    "sortingCode": "",
                    "sublocality": ""
                })
            }),
            "privacy": "",
            "registrantContact": json!({}),
            "technicalContact": json!({})
        }),
        "createTime": "",
        "dnsSettings": json!({
            "customDns": json!({
                "dsRecords": (
                    json!({
                        "algorithm": "",
                        "digest": "",
                        "digestType": "",
                        "keyTag": 0
                    })
                ),
                "nameServers": ()
            }),
            "glueRecords": (
                json!({
                    "hostName": "",
                    "ipv4Addresses": (),
                    "ipv6Addresses": ()
                })
            ),
            "googleDomainsDns": json!({
                "dsRecords": (json!({})),
                "dsState": "",
                "nameServers": ()
            }),
            "googleDomainsRedirectsDataAvailable": false
        }),
        "domainName": "",
        "domainProperties": (),
        "expireTime": "",
        "issues": (),
        "labels": json!({}),
        "managementSettings": json!({
            "effectiveTransferLockState": "",
            "preferredRenewalMethod": "",
            "renewalMethod": "",
            "transferLockState": ""
        }),
        "name": "",
        "pendingContactSettings": json!({}),
        "registerFailureReason": "",
        "state": "",
        "supportedPrivacy": (),
        "transferFailureReason": ""
    });

    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);
}
curl --request PATCH \
  --url '{{baseUrl}}/v1/:+name' \
  --header 'content-type: application/json' \
  --data '{
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "createTime": "",
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "domainName": "",
  "domainProperties": [],
  "expireTime": "",
  "issues": [],
  "labels": {},
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "name": "",
  "pendingContactSettings": {},
  "registerFailureReason": "",
  "state": "",
  "supportedPrivacy": [],
  "transferFailureReason": ""
}'
echo '{
  "contactSettings": {
    "adminContact": {
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": {
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      }
    },
    "privacy": "",
    "registrantContact": {},
    "technicalContact": {}
  },
  "createTime": "",
  "dnsSettings": {
    "customDns": {
      "dsRecords": [
        {
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        }
      ],
      "nameServers": []
    },
    "glueRecords": [
      {
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      }
    ],
    "googleDomainsDns": {
      "dsRecords": [
        {}
      ],
      "dsState": "",
      "nameServers": []
    },
    "googleDomainsRedirectsDataAvailable": false
  },
  "domainName": "",
  "domainProperties": [],
  "expireTime": "",
  "issues": [],
  "labels": {},
  "managementSettings": {
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  },
  "name": "",
  "pendingContactSettings": {},
  "registerFailureReason": "",
  "state": "",
  "supportedPrivacy": [],
  "transferFailureReason": ""
}' |  \
  http PATCH '{{baseUrl}}/v1/:+name' \
  content-type:application/json
wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "contactSettings": {\n    "adminContact": {\n      "email": "",\n      "faxNumber": "",\n      "phoneNumber": "",\n      "postalAddress": {\n        "addressLines": [],\n        "administrativeArea": "",\n        "languageCode": "",\n        "locality": "",\n        "organization": "",\n        "postalCode": "",\n        "recipients": [],\n        "regionCode": "",\n        "revision": 0,\n        "sortingCode": "",\n        "sublocality": ""\n      }\n    },\n    "privacy": "",\n    "registrantContact": {},\n    "technicalContact": {}\n  },\n  "createTime": "",\n  "dnsSettings": {\n    "customDns": {\n      "dsRecords": [\n        {\n          "algorithm": "",\n          "digest": "",\n          "digestType": "",\n          "keyTag": 0\n        }\n      ],\n      "nameServers": []\n    },\n    "glueRecords": [\n      {\n        "hostName": "",\n        "ipv4Addresses": [],\n        "ipv6Addresses": []\n      }\n    ],\n    "googleDomainsDns": {\n      "dsRecords": [\n        {}\n      ],\n      "dsState": "",\n      "nameServers": []\n    },\n    "googleDomainsRedirectsDataAvailable": false\n  },\n  "domainName": "",\n  "domainProperties": [],\n  "expireTime": "",\n  "issues": [],\n  "labels": {},\n  "managementSettings": {\n    "effectiveTransferLockState": "",\n    "preferredRenewalMethod": "",\n    "renewalMethod": "",\n    "transferLockState": ""\n  },\n  "name": "",\n  "pendingContactSettings": {},\n  "registerFailureReason": "",\n  "state": "",\n  "supportedPrivacy": [],\n  "transferFailureReason": ""\n}' \
  --output-document \
  - '{{baseUrl}}/v1/:+name'
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "contactSettings": [
    "adminContact": [
      "email": "",
      "faxNumber": "",
      "phoneNumber": "",
      "postalAddress": [
        "addressLines": [],
        "administrativeArea": "",
        "languageCode": "",
        "locality": "",
        "organization": "",
        "postalCode": "",
        "recipients": [],
        "regionCode": "",
        "revision": 0,
        "sortingCode": "",
        "sublocality": ""
      ]
    ],
    "privacy": "",
    "registrantContact": [],
    "technicalContact": []
  ],
  "createTime": "",
  "dnsSettings": [
    "customDns": [
      "dsRecords": [
        [
          "algorithm": "",
          "digest": "",
          "digestType": "",
          "keyTag": 0
        ]
      ],
      "nameServers": []
    ],
    "glueRecords": [
      [
        "hostName": "",
        "ipv4Addresses": [],
        "ipv6Addresses": []
      ]
    ],
    "googleDomainsDns": [
      "dsRecords": [[]],
      "dsState": "",
      "nameServers": []
    ],
    "googleDomainsRedirectsDataAvailable": false
  ],
  "domainName": "",
  "domainProperties": [],
  "expireTime": "",
  "issues": [],
  "labels": [],
  "managementSettings": [
    "effectiveTransferLockState": "",
    "preferredRenewalMethod": "",
    "renewalMethod": "",
    "transferLockState": ""
  ],
  "name": "",
  "pendingContactSettings": [],
  "registerFailureReason": "",
  "state": "",
  "supportedPrivacy": [],
  "transferFailureReason": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+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()
POST domains.projects.locations.registrations.register
{{baseUrl}}/v1/:+parent/registrations:register
QUERY PARAMS

parent
BODY json

{
  "contactNotices": [],
  "domainNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+parent/registrations:register");

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  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/:+parent/registrations:register" {:content-type :json
                                                                               :form-params {:contactNotices []
                                                                                             :domainNotices []
                                                                                             :registration {:contactSettings {:adminContact {:email ""
                                                                                                                                             :faxNumber ""
                                                                                                                                             :phoneNumber ""
                                                                                                                                             :postalAddress {:addressLines []
                                                                                                                                                             :administrativeArea ""
                                                                                                                                                             :languageCode ""
                                                                                                                                                             :locality ""
                                                                                                                                                             :organization ""
                                                                                                                                                             :postalCode ""
                                                                                                                                                             :recipients []
                                                                                                                                                             :regionCode ""
                                                                                                                                                             :revision 0
                                                                                                                                                             :sortingCode ""
                                                                                                                                                             :sublocality ""}}
                                                                                                                              :privacy ""
                                                                                                                              :registrantContact {}
                                                                                                                              :technicalContact {}}
                                                                                                            :createTime ""
                                                                                                            :dnsSettings {:customDns {:dsRecords [{:algorithm ""
                                                                                                                                                   :digest ""
                                                                                                                                                   :digestType ""
                                                                                                                                                   :keyTag 0}]
                                                                                                                                      :nameServers []}
                                                                                                                          :glueRecords [{:hostName ""
                                                                                                                                         :ipv4Addresses []
                                                                                                                                         :ipv6Addresses []}]
                                                                                                                          :googleDomainsDns {:dsRecords [{}]
                                                                                                                                             :dsState ""
                                                                                                                                             :nameServers []}
                                                                                                                          :googleDomainsRedirectsDataAvailable false}
                                                                                                            :domainName ""
                                                                                                            :domainProperties []
                                                                                                            :expireTime ""
                                                                                                            :issues []
                                                                                                            :labels {}
                                                                                                            :managementSettings {:effectiveTransferLockState ""
                                                                                                                                 :preferredRenewalMethod ""
                                                                                                                                 :renewalMethod ""
                                                                                                                                 :transferLockState ""}
                                                                                                            :name ""
                                                                                                            :pendingContactSettings {}
                                                                                                            :registerFailureReason ""
                                                                                                            :state ""
                                                                                                            :supportedPrivacy []
                                                                                                            :transferFailureReason ""}
                                                                                             :validateOnly false
                                                                                             :yearlyPrice {:currencyCode ""
                                                                                                           :nanos 0
                                                                                                           :units ""}}})
require "http/client"

url = "{{baseUrl}}/v1/:+parent/registrations:register"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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}}/v1/:+parent/registrations:register"),
    Content = new StringContent("{\n  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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}}/v1/:+parent/registrations:register");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+parent/registrations:register"

	payload := strings.NewReader("{\n  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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/v1/:+parent/registrations:register HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1785

{
  "contactNotices": [],
  "domainNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:+parent/registrations:register")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+parent/registrations:register"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:+parent/registrations:register")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+parent/registrations:register")
  .header("content-type", "application/json")
  .body("{\n  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}")
  .asString();
const data = JSON.stringify({
  contactNotices: [],
  domainNotices: [],
  registration: {
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    createTime: '',
    dnsSettings: {
      customDns: {
        dsRecords: [
          {
            algorithm: '',
            digest: '',
            digestType: '',
            keyTag: 0
          }
        ],
        nameServers: []
      },
      glueRecords: [
        {
          hostName: '',
          ipv4Addresses: [],
          ipv6Addresses: []
        }
      ],
      googleDomainsDns: {
        dsRecords: [
          {}
        ],
        dsState: '',
        nameServers: []
      },
      googleDomainsRedirectsDataAvailable: false
    },
    domainName: '',
    domainProperties: [],
    expireTime: '',
    issues: [],
    labels: {},
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    name: '',
    pendingContactSettings: {},
    registerFailureReason: '',
    state: '',
    supportedPrivacy: [],
    transferFailureReason: ''
  },
  validateOnly: false,
  yearlyPrice: {
    currencyCode: '',
    nanos: 0,
    units: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/:+parent/registrations:register');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+parent/registrations:register',
  headers: {'content-type': 'application/json'},
  data: {
    contactNotices: [],
    domainNotices: [],
    registration: {
      contactSettings: {
        adminContact: {
          email: '',
          faxNumber: '',
          phoneNumber: '',
          postalAddress: {
            addressLines: [],
            administrativeArea: '',
            languageCode: '',
            locality: '',
            organization: '',
            postalCode: '',
            recipients: [],
            regionCode: '',
            revision: 0,
            sortingCode: '',
            sublocality: ''
          }
        },
        privacy: '',
        registrantContact: {},
        technicalContact: {}
      },
      createTime: '',
      dnsSettings: {
        customDns: {
          dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
          nameServers: []
        },
        glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
        googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
        googleDomainsRedirectsDataAvailable: false
      },
      domainName: '',
      domainProperties: [],
      expireTime: '',
      issues: [],
      labels: {},
      managementSettings: {
        effectiveTransferLockState: '',
        preferredRenewalMethod: '',
        renewalMethod: '',
        transferLockState: ''
      },
      name: '',
      pendingContactSettings: {},
      registerFailureReason: '',
      state: '',
      supportedPrivacy: [],
      transferFailureReason: ''
    },
    validateOnly: false,
    yearlyPrice: {currencyCode: '', nanos: 0, units: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+parent/registrations:register';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contactNotices":[],"domainNotices":[],"registration":{"contactSettings":{"adminContact":{"email":"","faxNumber":"","phoneNumber":"","postalAddress":{"addressLines":[],"administrativeArea":"","languageCode":"","locality":"","organization":"","postalCode":"","recipients":[],"regionCode":"","revision":0,"sortingCode":"","sublocality":""}},"privacy":"","registrantContact":{},"technicalContact":{}},"createTime":"","dnsSettings":{"customDns":{"dsRecords":[{"algorithm":"","digest":"","digestType":"","keyTag":0}],"nameServers":[]},"glueRecords":[{"hostName":"","ipv4Addresses":[],"ipv6Addresses":[]}],"googleDomainsDns":{"dsRecords":[{}],"dsState":"","nameServers":[]},"googleDomainsRedirectsDataAvailable":false},"domainName":"","domainProperties":[],"expireTime":"","issues":[],"labels":{},"managementSettings":{"effectiveTransferLockState":"","preferredRenewalMethod":"","renewalMethod":"","transferLockState":""},"name":"","pendingContactSettings":{},"registerFailureReason":"","state":"","supportedPrivacy":[],"transferFailureReason":""},"validateOnly":false,"yearlyPrice":{"currencyCode":"","nanos":0,"units":""}}'
};

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}}/v1/:+parent/registrations:register',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "contactNotices": [],\n  "domainNotices": [],\n  "registration": {\n    "contactSettings": {\n      "adminContact": {\n        "email": "",\n        "faxNumber": "",\n        "phoneNumber": "",\n        "postalAddress": {\n          "addressLines": [],\n          "administrativeArea": "",\n          "languageCode": "",\n          "locality": "",\n          "organization": "",\n          "postalCode": "",\n          "recipients": [],\n          "regionCode": "",\n          "revision": 0,\n          "sortingCode": "",\n          "sublocality": ""\n        }\n      },\n      "privacy": "",\n      "registrantContact": {},\n      "technicalContact": {}\n    },\n    "createTime": "",\n    "dnsSettings": {\n      "customDns": {\n        "dsRecords": [\n          {\n            "algorithm": "",\n            "digest": "",\n            "digestType": "",\n            "keyTag": 0\n          }\n        ],\n        "nameServers": []\n      },\n      "glueRecords": [\n        {\n          "hostName": "",\n          "ipv4Addresses": [],\n          "ipv6Addresses": []\n        }\n      ],\n      "googleDomainsDns": {\n        "dsRecords": [\n          {}\n        ],\n        "dsState": "",\n        "nameServers": []\n      },\n      "googleDomainsRedirectsDataAvailable": false\n    },\n    "domainName": "",\n    "domainProperties": [],\n    "expireTime": "",\n    "issues": [],\n    "labels": {},\n    "managementSettings": {\n      "effectiveTransferLockState": "",\n      "preferredRenewalMethod": "",\n      "renewalMethod": "",\n      "transferLockState": ""\n    },\n    "name": "",\n    "pendingContactSettings": {},\n    "registerFailureReason": "",\n    "state": "",\n    "supportedPrivacy": [],\n    "transferFailureReason": ""\n  },\n  "validateOnly": false,\n  "yearlyPrice": {\n    "currencyCode": "",\n    "nanos": 0,\n    "units": ""\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  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+parent/registrations:register")
  .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/v1/:+parent/registrations:register',
  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({
  contactNotices: [],
  domainNotices: [],
  registration: {
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    createTime: '',
    dnsSettings: {
      customDns: {
        dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
        nameServers: []
      },
      glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
      googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
      googleDomainsRedirectsDataAvailable: false
    },
    domainName: '',
    domainProperties: [],
    expireTime: '',
    issues: [],
    labels: {},
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    name: '',
    pendingContactSettings: {},
    registerFailureReason: '',
    state: '',
    supportedPrivacy: [],
    transferFailureReason: ''
  },
  validateOnly: false,
  yearlyPrice: {currencyCode: '', nanos: 0, units: ''}
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+parent/registrations:register',
  headers: {'content-type': 'application/json'},
  body: {
    contactNotices: [],
    domainNotices: [],
    registration: {
      contactSettings: {
        adminContact: {
          email: '',
          faxNumber: '',
          phoneNumber: '',
          postalAddress: {
            addressLines: [],
            administrativeArea: '',
            languageCode: '',
            locality: '',
            organization: '',
            postalCode: '',
            recipients: [],
            regionCode: '',
            revision: 0,
            sortingCode: '',
            sublocality: ''
          }
        },
        privacy: '',
        registrantContact: {},
        technicalContact: {}
      },
      createTime: '',
      dnsSettings: {
        customDns: {
          dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
          nameServers: []
        },
        glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
        googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
        googleDomainsRedirectsDataAvailable: false
      },
      domainName: '',
      domainProperties: [],
      expireTime: '',
      issues: [],
      labels: {},
      managementSettings: {
        effectiveTransferLockState: '',
        preferredRenewalMethod: '',
        renewalMethod: '',
        transferLockState: ''
      },
      name: '',
      pendingContactSettings: {},
      registerFailureReason: '',
      state: '',
      supportedPrivacy: [],
      transferFailureReason: ''
    },
    validateOnly: false,
    yearlyPrice: {currencyCode: '', nanos: 0, units: ''}
  },
  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}}/v1/:+parent/registrations:register');

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

req.type('json');
req.send({
  contactNotices: [],
  domainNotices: [],
  registration: {
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    createTime: '',
    dnsSettings: {
      customDns: {
        dsRecords: [
          {
            algorithm: '',
            digest: '',
            digestType: '',
            keyTag: 0
          }
        ],
        nameServers: []
      },
      glueRecords: [
        {
          hostName: '',
          ipv4Addresses: [],
          ipv6Addresses: []
        }
      ],
      googleDomainsDns: {
        dsRecords: [
          {}
        ],
        dsState: '',
        nameServers: []
      },
      googleDomainsRedirectsDataAvailable: false
    },
    domainName: '',
    domainProperties: [],
    expireTime: '',
    issues: [],
    labels: {},
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    name: '',
    pendingContactSettings: {},
    registerFailureReason: '',
    state: '',
    supportedPrivacy: [],
    transferFailureReason: ''
  },
  validateOnly: false,
  yearlyPrice: {
    currencyCode: '',
    nanos: 0,
    units: ''
  }
});

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}}/v1/:+parent/registrations:register',
  headers: {'content-type': 'application/json'},
  data: {
    contactNotices: [],
    domainNotices: [],
    registration: {
      contactSettings: {
        adminContact: {
          email: '',
          faxNumber: '',
          phoneNumber: '',
          postalAddress: {
            addressLines: [],
            administrativeArea: '',
            languageCode: '',
            locality: '',
            organization: '',
            postalCode: '',
            recipients: [],
            regionCode: '',
            revision: 0,
            sortingCode: '',
            sublocality: ''
          }
        },
        privacy: '',
        registrantContact: {},
        technicalContact: {}
      },
      createTime: '',
      dnsSettings: {
        customDns: {
          dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
          nameServers: []
        },
        glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
        googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
        googleDomainsRedirectsDataAvailable: false
      },
      domainName: '',
      domainProperties: [],
      expireTime: '',
      issues: [],
      labels: {},
      managementSettings: {
        effectiveTransferLockState: '',
        preferredRenewalMethod: '',
        renewalMethod: '',
        transferLockState: ''
      },
      name: '',
      pendingContactSettings: {},
      registerFailureReason: '',
      state: '',
      supportedPrivacy: [],
      transferFailureReason: ''
    },
    validateOnly: false,
    yearlyPrice: {currencyCode: '', nanos: 0, units: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+parent/registrations:register';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contactNotices":[],"domainNotices":[],"registration":{"contactSettings":{"adminContact":{"email":"","faxNumber":"","phoneNumber":"","postalAddress":{"addressLines":[],"administrativeArea":"","languageCode":"","locality":"","organization":"","postalCode":"","recipients":[],"regionCode":"","revision":0,"sortingCode":"","sublocality":""}},"privacy":"","registrantContact":{},"technicalContact":{}},"createTime":"","dnsSettings":{"customDns":{"dsRecords":[{"algorithm":"","digest":"","digestType":"","keyTag":0}],"nameServers":[]},"glueRecords":[{"hostName":"","ipv4Addresses":[],"ipv6Addresses":[]}],"googleDomainsDns":{"dsRecords":[{}],"dsState":"","nameServers":[]},"googleDomainsRedirectsDataAvailable":false},"domainName":"","domainProperties":[],"expireTime":"","issues":[],"labels":{},"managementSettings":{"effectiveTransferLockState":"","preferredRenewalMethod":"","renewalMethod":"","transferLockState":""},"name":"","pendingContactSettings":{},"registerFailureReason":"","state":"","supportedPrivacy":[],"transferFailureReason":""},"validateOnly":false,"yearlyPrice":{"currencyCode":"","nanos":0,"units":""}}'
};

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 = @{ @"contactNotices": @[  ],
                              @"domainNotices": @[  ],
                              @"registration": @{ @"contactSettings": @{ @"adminContact": @{ @"email": @"", @"faxNumber": @"", @"phoneNumber": @"", @"postalAddress": @{ @"addressLines": @[  ], @"administrativeArea": @"", @"languageCode": @"", @"locality": @"", @"organization": @"", @"postalCode": @"", @"recipients": @[  ], @"regionCode": @"", @"revision": @0, @"sortingCode": @"", @"sublocality": @"" } }, @"privacy": @"", @"registrantContact": @{  }, @"technicalContact": @{  } }, @"createTime": @"", @"dnsSettings": @{ @"customDns": @{ @"dsRecords": @[ @{ @"algorithm": @"", @"digest": @"", @"digestType": @"", @"keyTag": @0 } ], @"nameServers": @[  ] }, @"glueRecords": @[ @{ @"hostName": @"", @"ipv4Addresses": @[  ], @"ipv6Addresses": @[  ] } ], @"googleDomainsDns": @{ @"dsRecords": @[ @{  } ], @"dsState": @"", @"nameServers": @[  ] }, @"googleDomainsRedirectsDataAvailable": @NO }, @"domainName": @"", @"domainProperties": @[  ], @"expireTime": @"", @"issues": @[  ], @"labels": @{  }, @"managementSettings": @{ @"effectiveTransferLockState": @"", @"preferredRenewalMethod": @"", @"renewalMethod": @"", @"transferLockState": @"" }, @"name": @"", @"pendingContactSettings": @{  }, @"registerFailureReason": @"", @"state": @"", @"supportedPrivacy": @[  ], @"transferFailureReason": @"" },
                              @"validateOnly": @NO,
                              @"yearlyPrice": @{ @"currencyCode": @"", @"nanos": @0, @"units": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:+parent/registrations:register"]
                                                       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}}/v1/:+parent/registrations:register" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+parent/registrations:register",
  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([
    'contactNotices' => [
        
    ],
    'domainNotices' => [
        
    ],
    'registration' => [
        'contactSettings' => [
                'adminContact' => [
                                'email' => '',
                                'faxNumber' => '',
                                'phoneNumber' => '',
                                'postalAddress' => [
                                                                'addressLines' => [
                                                                                                                                
                                                                ],
                                                                'administrativeArea' => '',
                                                                'languageCode' => '',
                                                                'locality' => '',
                                                                'organization' => '',
                                                                'postalCode' => '',
                                                                'recipients' => [
                                                                                                                                
                                                                ],
                                                                'regionCode' => '',
                                                                'revision' => 0,
                                                                'sortingCode' => '',
                                                                'sublocality' => ''
                                ]
                ],
                'privacy' => '',
                'registrantContact' => [
                                
                ],
                'technicalContact' => [
                                
                ]
        ],
        'createTime' => '',
        'dnsSettings' => [
                'customDns' => [
                                'dsRecords' => [
                                                                [
                                                                                                                                'algorithm' => '',
                                                                                                                                'digest' => '',
                                                                                                                                'digestType' => '',
                                                                                                                                'keyTag' => 0
                                                                ]
                                ],
                                'nameServers' => [
                                                                
                                ]
                ],
                'glueRecords' => [
                                [
                                                                'hostName' => '',
                                                                'ipv4Addresses' => [
                                                                                                                                
                                                                ],
                                                                'ipv6Addresses' => [
                                                                                                                                
                                                                ]
                                ]
                ],
                'googleDomainsDns' => [
                                'dsRecords' => [
                                                                [
                                                                                                                                
                                                                ]
                                ],
                                'dsState' => '',
                                'nameServers' => [
                                                                
                                ]
                ],
                'googleDomainsRedirectsDataAvailable' => null
        ],
        'domainName' => '',
        'domainProperties' => [
                
        ],
        'expireTime' => '',
        'issues' => [
                
        ],
        'labels' => [
                
        ],
        'managementSettings' => [
                'effectiveTransferLockState' => '',
                'preferredRenewalMethod' => '',
                'renewalMethod' => '',
                'transferLockState' => ''
        ],
        'name' => '',
        'pendingContactSettings' => [
                
        ],
        'registerFailureReason' => '',
        'state' => '',
        'supportedPrivacy' => [
                
        ],
        'transferFailureReason' => ''
    ],
    'validateOnly' => null,
    'yearlyPrice' => [
        'currencyCode' => '',
        'nanos' => 0,
        'units' => ''
    ]
  ]),
  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}}/v1/:+parent/registrations:register', [
  'body' => '{
  "contactNotices": [],
  "domainNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+parent/registrations:register');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'contactNotices' => [
    
  ],
  'domainNotices' => [
    
  ],
  'registration' => [
    'contactSettings' => [
        'adminContact' => [
                'email' => '',
                'faxNumber' => '',
                'phoneNumber' => '',
                'postalAddress' => [
                                'addressLines' => [
                                                                
                                ],
                                'administrativeArea' => '',
                                'languageCode' => '',
                                'locality' => '',
                                'organization' => '',
                                'postalCode' => '',
                                'recipients' => [
                                                                
                                ],
                                'regionCode' => '',
                                'revision' => 0,
                                'sortingCode' => '',
                                'sublocality' => ''
                ]
        ],
        'privacy' => '',
        'registrantContact' => [
                
        ],
        'technicalContact' => [
                
        ]
    ],
    'createTime' => '',
    'dnsSettings' => [
        'customDns' => [
                'dsRecords' => [
                                [
                                                                'algorithm' => '',
                                                                'digest' => '',
                                                                'digestType' => '',
                                                                'keyTag' => 0
                                ]
                ],
                'nameServers' => [
                                
                ]
        ],
        'glueRecords' => [
                [
                                'hostName' => '',
                                'ipv4Addresses' => [
                                                                
                                ],
                                'ipv6Addresses' => [
                                                                
                                ]
                ]
        ],
        'googleDomainsDns' => [
                'dsRecords' => [
                                [
                                                                
                                ]
                ],
                'dsState' => '',
                'nameServers' => [
                                
                ]
        ],
        'googleDomainsRedirectsDataAvailable' => null
    ],
    'domainName' => '',
    'domainProperties' => [
        
    ],
    'expireTime' => '',
    'issues' => [
        
    ],
    'labels' => [
        
    ],
    'managementSettings' => [
        'effectiveTransferLockState' => '',
        'preferredRenewalMethod' => '',
        'renewalMethod' => '',
        'transferLockState' => ''
    ],
    'name' => '',
    'pendingContactSettings' => [
        
    ],
    'registerFailureReason' => '',
    'state' => '',
    'supportedPrivacy' => [
        
    ],
    'transferFailureReason' => ''
  ],
  'validateOnly' => null,
  'yearlyPrice' => [
    'currencyCode' => '',
    'nanos' => 0,
    'units' => ''
  ]
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'contactNotices' => [
    
  ],
  'domainNotices' => [
    
  ],
  'registration' => [
    'contactSettings' => [
        'adminContact' => [
                'email' => '',
                'faxNumber' => '',
                'phoneNumber' => '',
                'postalAddress' => [
                                'addressLines' => [
                                                                
                                ],
                                'administrativeArea' => '',
                                'languageCode' => '',
                                'locality' => '',
                                'organization' => '',
                                'postalCode' => '',
                                'recipients' => [
                                                                
                                ],
                                'regionCode' => '',
                                'revision' => 0,
                                'sortingCode' => '',
                                'sublocality' => ''
                ]
        ],
        'privacy' => '',
        'registrantContact' => [
                
        ],
        'technicalContact' => [
                
        ]
    ],
    'createTime' => '',
    'dnsSettings' => [
        'customDns' => [
                'dsRecords' => [
                                [
                                                                'algorithm' => '',
                                                                'digest' => '',
                                                                'digestType' => '',
                                                                'keyTag' => 0
                                ]
                ],
                'nameServers' => [
                                
                ]
        ],
        'glueRecords' => [
                [
                                'hostName' => '',
                                'ipv4Addresses' => [
                                                                
                                ],
                                'ipv6Addresses' => [
                                                                
                                ]
                ]
        ],
        'googleDomainsDns' => [
                'dsRecords' => [
                                [
                                                                
                                ]
                ],
                'dsState' => '',
                'nameServers' => [
                                
                ]
        ],
        'googleDomainsRedirectsDataAvailable' => null
    ],
    'domainName' => '',
    'domainProperties' => [
        
    ],
    'expireTime' => '',
    'issues' => [
        
    ],
    'labels' => [
        
    ],
    'managementSettings' => [
        'effectiveTransferLockState' => '',
        'preferredRenewalMethod' => '',
        'renewalMethod' => '',
        'transferLockState' => ''
    ],
    'name' => '',
    'pendingContactSettings' => [
        
    ],
    'registerFailureReason' => '',
    'state' => '',
    'supportedPrivacy' => [
        
    ],
    'transferFailureReason' => ''
  ],
  'validateOnly' => null,
  'yearlyPrice' => [
    'currencyCode' => '',
    'nanos' => 0,
    'units' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/:+parent/registrations:register');
$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}}/v1/:+parent/registrations:register' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contactNotices": [],
  "domainNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+parent/registrations:register' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contactNotices": [],
  "domainNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}'
import http.client

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

payload = "{\n  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1/:+parent/registrations:register", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+parent/registrations:register"

payload = {
    "contactNotices": [],
    "domainNotices": [],
    "registration": {
        "contactSettings": {
            "adminContact": {
                "email": "",
                "faxNumber": "",
                "phoneNumber": "",
                "postalAddress": {
                    "addressLines": [],
                    "administrativeArea": "",
                    "languageCode": "",
                    "locality": "",
                    "organization": "",
                    "postalCode": "",
                    "recipients": [],
                    "regionCode": "",
                    "revision": 0,
                    "sortingCode": "",
                    "sublocality": ""
                }
            },
            "privacy": "",
            "registrantContact": {},
            "technicalContact": {}
        },
        "createTime": "",
        "dnsSettings": {
            "customDns": {
                "dsRecords": [
                    {
                        "algorithm": "",
                        "digest": "",
                        "digestType": "",
                        "keyTag": 0
                    }
                ],
                "nameServers": []
            },
            "glueRecords": [
                {
                    "hostName": "",
                    "ipv4Addresses": [],
                    "ipv6Addresses": []
                }
            ],
            "googleDomainsDns": {
                "dsRecords": [{}],
                "dsState": "",
                "nameServers": []
            },
            "googleDomainsRedirectsDataAvailable": False
        },
        "domainName": "",
        "domainProperties": [],
        "expireTime": "",
        "issues": [],
        "labels": {},
        "managementSettings": {
            "effectiveTransferLockState": "",
            "preferredRenewalMethod": "",
            "renewalMethod": "",
            "transferLockState": ""
        },
        "name": "",
        "pendingContactSettings": {},
        "registerFailureReason": "",
        "state": "",
        "supportedPrivacy": [],
        "transferFailureReason": ""
    },
    "validateOnly": False,
    "yearlyPrice": {
        "currencyCode": "",
        "nanos": 0,
        "units": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+parent/registrations:register"

payload <- "{\n  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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}}/v1/:+parent/registrations:register")

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  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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/v1/:+parent/registrations:register') do |req|
  req.body = "{\n  \"contactNotices\": [],\n  \"domainNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+parent/registrations:register";

    let payload = json!({
        "contactNotices": (),
        "domainNotices": (),
        "registration": json!({
            "contactSettings": json!({
                "adminContact": json!({
                    "email": "",
                    "faxNumber": "",
                    "phoneNumber": "",
                    "postalAddress": json!({
                        "addressLines": (),
                        "administrativeArea": "",
                        "languageCode": "",
                        "locality": "",
                        "organization": "",
                        "postalCode": "",
                        "recipients": (),
                        "regionCode": "",
                        "revision": 0,
                        "sortingCode": "",
                        "sublocality": ""
                    })
                }),
                "privacy": "",
                "registrantContact": json!({}),
                "technicalContact": json!({})
            }),
            "createTime": "",
            "dnsSettings": json!({
                "customDns": json!({
                    "dsRecords": (
                        json!({
                            "algorithm": "",
                            "digest": "",
                            "digestType": "",
                            "keyTag": 0
                        })
                    ),
                    "nameServers": ()
                }),
                "glueRecords": (
                    json!({
                        "hostName": "",
                        "ipv4Addresses": (),
                        "ipv6Addresses": ()
                    })
                ),
                "googleDomainsDns": json!({
                    "dsRecords": (json!({})),
                    "dsState": "",
                    "nameServers": ()
                }),
                "googleDomainsRedirectsDataAvailable": false
            }),
            "domainName": "",
            "domainProperties": (),
            "expireTime": "",
            "issues": (),
            "labels": json!({}),
            "managementSettings": json!({
                "effectiveTransferLockState": "",
                "preferredRenewalMethod": "",
                "renewalMethod": "",
                "transferLockState": ""
            }),
            "name": "",
            "pendingContactSettings": json!({}),
            "registerFailureReason": "",
            "state": "",
            "supportedPrivacy": (),
            "transferFailureReason": ""
        }),
        "validateOnly": false,
        "yearlyPrice": json!({
            "currencyCode": "",
            "nanos": 0,
            "units": ""
        })
    });

    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);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+parent/registrations:register' \
  --header 'content-type: application/json' \
  --data '{
  "contactNotices": [],
  "domainNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}'
echo '{
  "contactNotices": [],
  "domainNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}' |  \
  http POST '{{baseUrl}}/v1/:+parent/registrations:register' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "contactNotices": [],\n  "domainNotices": [],\n  "registration": {\n    "contactSettings": {\n      "adminContact": {\n        "email": "",\n        "faxNumber": "",\n        "phoneNumber": "",\n        "postalAddress": {\n          "addressLines": [],\n          "administrativeArea": "",\n          "languageCode": "",\n          "locality": "",\n          "organization": "",\n          "postalCode": "",\n          "recipients": [],\n          "regionCode": "",\n          "revision": 0,\n          "sortingCode": "",\n          "sublocality": ""\n        }\n      },\n      "privacy": "",\n      "registrantContact": {},\n      "technicalContact": {}\n    },\n    "createTime": "",\n    "dnsSettings": {\n      "customDns": {\n        "dsRecords": [\n          {\n            "algorithm": "",\n            "digest": "",\n            "digestType": "",\n            "keyTag": 0\n          }\n        ],\n        "nameServers": []\n      },\n      "glueRecords": [\n        {\n          "hostName": "",\n          "ipv4Addresses": [],\n          "ipv6Addresses": []\n        }\n      ],\n      "googleDomainsDns": {\n        "dsRecords": [\n          {}\n        ],\n        "dsState": "",\n        "nameServers": []\n      },\n      "googleDomainsRedirectsDataAvailable": false\n    },\n    "domainName": "",\n    "domainProperties": [],\n    "expireTime": "",\n    "issues": [],\n    "labels": {},\n    "managementSettings": {\n      "effectiveTransferLockState": "",\n      "preferredRenewalMethod": "",\n      "renewalMethod": "",\n      "transferLockState": ""\n    },\n    "name": "",\n    "pendingContactSettings": {},\n    "registerFailureReason": "",\n    "state": "",\n    "supportedPrivacy": [],\n    "transferFailureReason": ""\n  },\n  "validateOnly": false,\n  "yearlyPrice": {\n    "currencyCode": "",\n    "nanos": 0,\n    "units": ""\n  }\n}' \
  --output-document \
  - '{{baseUrl}}/v1/:+parent/registrations:register'
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "contactNotices": [],
  "domainNotices": [],
  "registration": [
    "contactSettings": [
      "adminContact": [
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": [
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        ]
      ],
      "privacy": "",
      "registrantContact": [],
      "technicalContact": []
    ],
    "createTime": "",
    "dnsSettings": [
      "customDns": [
        "dsRecords": [
          [
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          ]
        ],
        "nameServers": []
      ],
      "glueRecords": [
        [
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        ]
      ],
      "googleDomainsDns": [
        "dsRecords": [[]],
        "dsState": "",
        "nameServers": []
      ],
      "googleDomainsRedirectsDataAvailable": false
    ],
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": [],
    "managementSettings": [
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    ],
    "name": "",
    "pendingContactSettings": [],
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  ],
  "validateOnly": false,
  "yearlyPrice": [
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+parent/registrations:register")! 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()
POST domains.projects.locations.registrations.renewDomain
{{baseUrl}}/v1/:+registration:renewDomain
QUERY PARAMS

registration
BODY json

{
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+registration:renewDomain");

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  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/:+registration:renewDomain" {:content-type :json
                                                                          :form-params {:validateOnly false
                                                                                        :yearlyPrice {:currencyCode ""
                                                                                                      :nanos 0
                                                                                                      :units ""}}})
require "http/client"

url = "{{baseUrl}}/v1/:+registration:renewDomain"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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}}/v1/:+registration:renewDomain"),
    Content = new StringContent("{\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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}}/v1/:+registration:renewDomain");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+registration:renewDomain"

	payload := strings.NewReader("{\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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/v1/:+registration:renewDomain HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:+registration:renewDomain")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+registration:renewDomain"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:renewDomain")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+registration:renewDomain")
  .header("content-type", "application/json")
  .body("{\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}")
  .asString();
const data = JSON.stringify({
  validateOnly: false,
  yearlyPrice: {
    currencyCode: '',
    nanos: 0,
    units: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/:+registration:renewDomain');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:renewDomain',
  headers: {'content-type': 'application/json'},
  data: {validateOnly: false, yearlyPrice: {currencyCode: '', nanos: 0, units: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+registration:renewDomain';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"validateOnly":false,"yearlyPrice":{"currencyCode":"","nanos":0,"units":""}}'
};

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}}/v1/:+registration:renewDomain',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "validateOnly": false,\n  "yearlyPrice": {\n    "currencyCode": "",\n    "nanos": 0,\n    "units": ""\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  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:renewDomain")
  .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/v1/:+registration:renewDomain',
  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({validateOnly: false, yearlyPrice: {currencyCode: '', nanos: 0, units: ''}}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:renewDomain',
  headers: {'content-type': 'application/json'},
  body: {validateOnly: false, yearlyPrice: {currencyCode: '', nanos: 0, units: ''}},
  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}}/v1/:+registration:renewDomain');

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

req.type('json');
req.send({
  validateOnly: false,
  yearlyPrice: {
    currencyCode: '',
    nanos: 0,
    units: ''
  }
});

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}}/v1/:+registration:renewDomain',
  headers: {'content-type': 'application/json'},
  data: {validateOnly: false, yearlyPrice: {currencyCode: '', nanos: 0, units: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+registration:renewDomain';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"validateOnly":false,"yearlyPrice":{"currencyCode":"","nanos":0,"units":""}}'
};

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 = @{ @"validateOnly": @NO,
                              @"yearlyPrice": @{ @"currencyCode": @"", @"nanos": @0, @"units": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:+registration:renewDomain"]
                                                       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}}/v1/:+registration:renewDomain" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+registration:renewDomain",
  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([
    'validateOnly' => null,
    'yearlyPrice' => [
        'currencyCode' => '',
        'nanos' => 0,
        'units' => ''
    ]
  ]),
  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}}/v1/:+registration:renewDomain', [
  'body' => '{
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+registration:renewDomain');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'validateOnly' => null,
  'yearlyPrice' => [
    'currencyCode' => '',
    'nanos' => 0,
    'units' => ''
  ]
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'validateOnly' => null,
  'yearlyPrice' => [
    'currencyCode' => '',
    'nanos' => 0,
    'units' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/:+registration:renewDomain');
$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}}/v1/:+registration:renewDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+registration:renewDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}'
import http.client

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

payload = "{\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1/:+registration:renewDomain", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+registration:renewDomain"

payload = {
    "validateOnly": False,
    "yearlyPrice": {
        "currencyCode": "",
        "nanos": 0,
        "units": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+registration:renewDomain"

payload <- "{\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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}}/v1/:+registration:renewDomain")

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  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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/v1/:+registration:renewDomain') do |req|
  req.body = "{\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+registration:renewDomain";

    let payload = json!({
        "validateOnly": false,
        "yearlyPrice": json!({
            "currencyCode": "",
            "nanos": 0,
            "units": ""
        })
    });

    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);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+registration:renewDomain' \
  --header 'content-type: application/json' \
  --data '{
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}'
echo '{
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}' |  \
  http POST '{{baseUrl}}/v1/:+registration:renewDomain' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "validateOnly": false,\n  "yearlyPrice": {\n    "currencyCode": "",\n    "nanos": 0,\n    "units": ""\n  }\n}' \
  --output-document \
  - '{{baseUrl}}/v1/:+registration:renewDomain'
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "validateOnly": false,
  "yearlyPrice": [
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+registration:renewDomain")! 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()
POST domains.projects.locations.registrations.resetAuthorizationCode
{{baseUrl}}/v1/:+registration:resetAuthorizationCode
QUERY PARAMS

registration
BODY json

{}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+registration:resetAuthorizationCode");

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}}/v1/:+registration:resetAuthorizationCode" {:content-type :json})
require "http/client"

url = "{{baseUrl}}/v1/:+registration:resetAuthorizationCode"
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}}/v1/:+registration:resetAuthorizationCode"),
    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}}/v1/:+registration:resetAuthorizationCode");
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}}/v1/:+registration:resetAuthorizationCode"

	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/v1/:+registration:resetAuthorizationCode HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+registration:resetAuthorizationCode"))
    .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}}/v1/:+registration:resetAuthorizationCode")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+registration:resetAuthorizationCode")
  .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}}/v1/:+registration:resetAuthorizationCode');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+registration:resetAuthorizationCode',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+registration:resetAuthorizationCode';
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}}/v1/:+registration:resetAuthorizationCode',
  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}}/v1/:+registration:resetAuthorizationCode")
  .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/v1/:+registration:resetAuthorizationCode',
  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}}/v1/:+registration:resetAuthorizationCode',
  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}}/v1/:+registration:resetAuthorizationCode');

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}}/v1/:+registration:resetAuthorizationCode',
  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}}/v1/:+registration:resetAuthorizationCode';
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}}/v1/:+registration:resetAuthorizationCode"]
                                                       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}}/v1/:+registration:resetAuthorizationCode" 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}}/v1/:+registration:resetAuthorizationCode",
  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}}/v1/:+registration:resetAuthorizationCode', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+registration:resetAuthorizationCode');
$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}}/v1/:+registration:resetAuthorizationCode');
$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}}/v1/:+registration:resetAuthorizationCode' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+registration:resetAuthorizationCode' -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/v1/:+registration:resetAuthorizationCode", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+registration:resetAuthorizationCode"

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

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+registration:resetAuthorizationCode"

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}}/v1/:+registration:resetAuthorizationCode")

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/v1/:+registration:resetAuthorizationCode') 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}}/v1/:+registration:resetAuthorizationCode";

    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);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+registration:resetAuthorizationCode' \
  --header 'content-type: application/json' \
  --data '{}'
echo '{}' |  \
  http POST '{{baseUrl}}/v1/:+registration:resetAuthorizationCode' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - '{{baseUrl}}/v1/:+registration:resetAuthorizationCode'
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}}/v1/:+registration:resetAuthorizationCode")! 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()
GET domains.projects.locations.registrations.retrieveAuthorizationCode
{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode
QUERY PARAMS

registration
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode")
require "http/client"

url = "{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode"

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}}/v1/:+registration:retrieveAuthorizationCode"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode"

	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/v1/:+registration:retrieveAuthorizationCode HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode"))
    .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}}/v1/:+registration:retrieveAuthorizationCode")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode")
  .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}}/v1/:+registration:retrieveAuthorizationCode');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode';
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}}/v1/:+registration:retrieveAuthorizationCode',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode');

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}}/v1/:+registration:retrieveAuthorizationCode'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode';
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}}/v1/:+registration:retrieveAuthorizationCode"]
                                                       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}}/v1/:+registration:retrieveAuthorizationCode" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode",
  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}}/v1/:+registration:retrieveAuthorizationCode');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+registration:retrieveAuthorizationCode")

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

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

url = "{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode")

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/v1/:+registration:retrieveAuthorizationCode') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode";

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode'
http GET '{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+registration:retrieveAuthorizationCode")! 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()
GET domains.projects.locations.registrations.retrieveGoogleDomainsDnsRecords
{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords
QUERY PARAMS

registration
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords")
require "http/client"

url = "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords"

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}}/v1/:+registration:retrieveGoogleDomainsDnsRecords"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords"

	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/v1/:+registration:retrieveGoogleDomainsDnsRecords HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords"))
    .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}}/v1/:+registration:retrieveGoogleDomainsDnsRecords")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords")
  .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}}/v1/:+registration:retrieveGoogleDomainsDnsRecords');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords';
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}}/v1/:+registration:retrieveGoogleDomainsDnsRecords',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords');

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}}/v1/:+registration:retrieveGoogleDomainsDnsRecords'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords';
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}}/v1/:+registration:retrieveGoogleDomainsDnsRecords"]
                                                       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}}/v1/:+registration:retrieveGoogleDomainsDnsRecords" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords",
  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}}/v1/:+registration:retrieveGoogleDomainsDnsRecords');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+registration:retrieveGoogleDomainsDnsRecords")

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

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

url = "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords")

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/v1/:+registration:retrieveGoogleDomainsDnsRecords') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords";

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords'
http GET '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsDnsRecords")! 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()
GET domains.projects.locations.registrations.retrieveGoogleDomainsForwardingConfig
{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig
QUERY PARAMS

registration
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig")
require "http/client"

url = "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig"

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}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig"

	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/v1/:+registration:retrieveGoogleDomainsForwardingConfig HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig"))
    .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}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig")
  .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}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig';
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}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig');

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}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig';
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}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig"]
                                                       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}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig",
  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}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+registration:retrieveGoogleDomainsForwardingConfig")

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

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

url = "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig")

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/v1/:+registration:retrieveGoogleDomainsForwardingConfig') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig";

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig'
http GET '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+registration:retrieveGoogleDomainsForwardingConfig")! 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()
GET domains.projects.locations.registrations.retrieveImportableDomains
{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains
QUERY PARAMS

location
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains")
require "http/client"

url = "{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains"

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}}/v1/:+location/registrations:retrieveImportableDomains"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains"

	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/v1/:+location/registrations:retrieveImportableDomains HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains"))
    .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}}/v1/:+location/registrations:retrieveImportableDomains")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains")
  .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}}/v1/:+location/registrations:retrieveImportableDomains');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains';
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}}/v1/:+location/registrations:retrieveImportableDomains',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/:+location/registrations:retrieveImportableDomains',
  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}}/v1/:+location/registrations:retrieveImportableDomains'
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains');

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}}/v1/:+location/registrations:retrieveImportableDomains'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains';
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}}/v1/:+location/registrations:retrieveImportableDomains"]
                                                       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}}/v1/:+location/registrations:retrieveImportableDomains" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains",
  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}}/v1/:+location/registrations:retrieveImportableDomains');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+location/registrations:retrieveImportableDomains")

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

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

url = "{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains")

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/v1/:+location/registrations:retrieveImportableDomains') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains";

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains'
http GET '{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+location/registrations:retrieveImportableDomains")! 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()
GET domains.projects.locations.registrations.retrieveRegisterParameters
{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters
QUERY PARAMS

location
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters")
require "http/client"

url = "{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters"

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}}/v1/:+location/registrations:retrieveRegisterParameters"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters"

	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/v1/:+location/registrations:retrieveRegisterParameters HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters"))
    .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}}/v1/:+location/registrations:retrieveRegisterParameters")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters")
  .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}}/v1/:+location/registrations:retrieveRegisterParameters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters';
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}}/v1/:+location/registrations:retrieveRegisterParameters',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/:+location/registrations:retrieveRegisterParameters',
  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}}/v1/:+location/registrations:retrieveRegisterParameters'
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters');

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}}/v1/:+location/registrations:retrieveRegisterParameters'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters';
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}}/v1/:+location/registrations:retrieveRegisterParameters"]
                                                       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}}/v1/:+location/registrations:retrieveRegisterParameters" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters",
  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}}/v1/:+location/registrations:retrieveRegisterParameters');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+location/registrations:retrieveRegisterParameters")

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

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

url = "{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters")

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/v1/:+location/registrations:retrieveRegisterParameters') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters";

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters'
http GET '{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+location/registrations:retrieveRegisterParameters")! 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()
GET domains.projects.locations.registrations.retrieveTransferParameters
{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters
QUERY PARAMS

location
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters")
require "http/client"

url = "{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters"

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}}/v1/:+location/registrations:retrieveTransferParameters"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters"

	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/v1/:+location/registrations:retrieveTransferParameters HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters"))
    .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}}/v1/:+location/registrations:retrieveTransferParameters")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters")
  .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}}/v1/:+location/registrations:retrieveTransferParameters');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters';
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}}/v1/:+location/registrations:retrieveTransferParameters',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/:+location/registrations:retrieveTransferParameters',
  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}}/v1/:+location/registrations:retrieveTransferParameters'
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters');

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}}/v1/:+location/registrations:retrieveTransferParameters'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters';
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}}/v1/:+location/registrations:retrieveTransferParameters"]
                                                       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}}/v1/:+location/registrations:retrieveTransferParameters" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters",
  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}}/v1/:+location/registrations:retrieveTransferParameters');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+location/registrations:retrieveTransferParameters")

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

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

url = "{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters")

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/v1/:+location/registrations:retrieveTransferParameters') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters";

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters'
http GET '{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+location/registrations:retrieveTransferParameters")! 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()
GET domains.projects.locations.registrations.searchDomains
{{baseUrl}}/v1/:+location/registrations:searchDomains
QUERY PARAMS

location
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+location/registrations:searchDomains");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/:+location/registrations:searchDomains")
require "http/client"

url = "{{baseUrl}}/v1/:+location/registrations:searchDomains"

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}}/v1/:+location/registrations:searchDomains"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/v1/:+location/registrations:searchDomains");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+location/registrations:searchDomains"

	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/v1/:+location/registrations:searchDomains HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/:+location/registrations:searchDomains")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+location/registrations:searchDomains"))
    .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}}/v1/:+location/registrations:searchDomains")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/v1/:+location/registrations:searchDomains")
  .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}}/v1/:+location/registrations:searchDomains');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/:+location/registrations:searchDomains'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+location/registrations:searchDomains';
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}}/v1/:+location/registrations:searchDomains',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+location/registrations:searchDomains")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/:+location/registrations:searchDomains',
  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}}/v1/:+location/registrations:searchDomains'
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/:+location/registrations:searchDomains');

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}}/v1/:+location/registrations:searchDomains'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+location/registrations:searchDomains';
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}}/v1/:+location/registrations:searchDomains"]
                                                       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}}/v1/:+location/registrations:searchDomains" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+location/registrations:searchDomains",
  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}}/v1/:+location/registrations:searchDomains');

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+location/registrations:searchDomains');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/v1/:+location/registrations:searchDomains');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/:+location/registrations:searchDomains' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+location/registrations:searchDomains' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/v1/:+location/registrations:searchDomains")

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

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

url = "{{baseUrl}}/v1/:+location/registrations:searchDomains"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+location/registrations:searchDomains"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/:+location/registrations:searchDomains")

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/v1/:+location/registrations:searchDomains') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+location/registrations:searchDomains";

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

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

    dbg!(results);
}
curl --request GET \
  --url '{{baseUrl}}/v1/:+location/registrations:searchDomains'
http GET '{{baseUrl}}/v1/:+location/registrations:searchDomains'
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v1/:+location/registrations:searchDomains'
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+location/registrations:searchDomains")! 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()
POST domains.projects.locations.registrations.setIamPolicy
{{baseUrl}}/v1/:+resource:setIamPolicy
QUERY PARAMS

resource
BODY json

{
  "policy": {
    "auditConfigs": [
      {
        "auditLogConfigs": [
          {
            "exemptedMembers": [],
            "logType": ""
          }
        ],
        "service": ""
      }
    ],
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  },
  "updateMask": ""
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+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    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/:+resource:setIamPolicy" {:content-type :json
                                                                       :form-params {:policy {:auditConfigs [{:auditLogConfigs [{:exemptedMembers []
                                                                                                                                 :logType ""}]
                                                                                                              :service ""}]
                                                                                              :bindings [{:condition {:description ""
                                                                                                                      :expression ""
                                                                                                                      :location ""
                                                                                                                      :title ""}
                                                                                                          :members []
                                                                                                          :role ""}]
                                                                                              :etag ""
                                                                                              :version 0}
                                                                                     :updateMask ""}})
require "http/client"

url = "{{baseUrl}}/v1/:+resource:setIamPolicy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"policy\": {\n    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\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}}/v1/:+resource:setIamPolicy"),
    Content = new StringContent("{\n  \"policy\": {\n    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\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}}/v1/:+resource:setIamPolicy");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"policy\": {\n    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+resource:setIamPolicy"

	payload := strings.NewReader("{\n  \"policy\": {\n    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\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/v1/:+resource:setIamPolicy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 488

{
  "policy": {
    "auditConfigs": [
      {
        "auditLogConfigs": [
          {
            "exemptedMembers": [],
            "logType": ""
          }
        ],
        "service": ""
      }
    ],
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  },
  "updateMask": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:+resource:setIamPolicy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"policy\": {\n    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+resource:setIamPolicy"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"policy\": {\n    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\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    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:+resource:setIamPolicy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+resource:setIamPolicy")
  .header("content-type", "application/json")
  .body("{\n  \"policy\": {\n    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  policy: {
    auditConfigs: [
      {
        auditLogConfigs: [
          {
            exemptedMembers: [],
            logType: ''
          }
        ],
        service: ''
      }
    ],
    bindings: [
      {
        condition: {
          description: '',
          expression: '',
          location: '',
          title: ''
        },
        members: [],
        role: ''
      }
    ],
    etag: '',
    version: 0
  },
  updateMask: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/:+resource:setIamPolicy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+resource:setIamPolicy',
  headers: {'content-type': 'application/json'},
  data: {
    policy: {
      auditConfigs: [{auditLogConfigs: [{exemptedMembers: [], logType: ''}], service: ''}],
      bindings: [
        {
          condition: {description: '', expression: '', location: '', title: ''},
          members: [],
          role: ''
        }
      ],
      etag: '',
      version: 0
    },
    updateMask: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+resource:setIamPolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"policy":{"auditConfigs":[{"auditLogConfigs":[{"exemptedMembers":[],"logType":""}],"service":""}],"bindings":[{"condition":{"description":"","expression":"","location":"","title":""},"members":[],"role":""}],"etag":"","version":0},"updateMask":""}'
};

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}}/v1/:+resource:setIamPolicy',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "policy": {\n    "auditConfigs": [\n      {\n        "auditLogConfigs": [\n          {\n            "exemptedMembers": [],\n            "logType": ""\n          }\n        ],\n        "service": ""\n      }\n    ],\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  "updateMask": ""\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    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+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/v1/:+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: {
    auditConfigs: [{auditLogConfigs: [{exemptedMembers: [], logType: ''}], service: ''}],
    bindings: [
      {
        condition: {description: '', expression: '', location: '', title: ''},
        members: [],
        role: ''
      }
    ],
    etag: '',
    version: 0
  },
  updateMask: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+resource:setIamPolicy',
  headers: {'content-type': 'application/json'},
  body: {
    policy: {
      auditConfigs: [{auditLogConfigs: [{exemptedMembers: [], logType: ''}], service: ''}],
      bindings: [
        {
          condition: {description: '', expression: '', location: '', title: ''},
          members: [],
          role: ''
        }
      ],
      etag: '',
      version: 0
    },
    updateMask: ''
  },
  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}}/v1/:+resource:setIamPolicy');

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

req.type('json');
req.send({
  policy: {
    auditConfigs: [
      {
        auditLogConfigs: [
          {
            exemptedMembers: [],
            logType: ''
          }
        ],
        service: ''
      }
    ],
    bindings: [
      {
        condition: {
          description: '',
          expression: '',
          location: '',
          title: ''
        },
        members: [],
        role: ''
      }
    ],
    etag: '',
    version: 0
  },
  updateMask: ''
});

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}}/v1/:+resource:setIamPolicy',
  headers: {'content-type': 'application/json'},
  data: {
    policy: {
      auditConfigs: [{auditLogConfigs: [{exemptedMembers: [], logType: ''}], service: ''}],
      bindings: [
        {
          condition: {description: '', expression: '', location: '', title: ''},
          members: [],
          role: ''
        }
      ],
      etag: '',
      version: 0
    },
    updateMask: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+resource:setIamPolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"policy":{"auditConfigs":[{"auditLogConfigs":[{"exemptedMembers":[],"logType":""}],"service":""}],"bindings":[{"condition":{"description":"","expression":"","location":"","title":""},"members":[],"role":""}],"etag":"","version":0},"updateMask":""}'
};

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": @{ @"auditConfigs": @[ @{ @"auditLogConfigs": @[ @{ @"exemptedMembers": @[  ], @"logType": @"" } ], @"service": @"" } ], @"bindings": @[ @{ @"condition": @{ @"description": @"", @"expression": @"", @"location": @"", @"title": @"" }, @"members": @[  ], @"role": @"" } ], @"etag": @"", @"version": @0 },
                              @"updateMask": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:+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}}/v1/:+resource:setIamPolicy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"policy\": {\n    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+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' => [
        'auditConfigs' => [
                [
                                'auditLogConfigs' => [
                                                                [
                                                                                                                                'exemptedMembers' => [
                                                                                                                                                                                                                                                                
                                                                                                                                ],
                                                                                                                                'logType' => ''
                                                                ]
                                ],
                                'service' => ''
                ]
        ],
        'bindings' => [
                [
                                'condition' => [
                                                                'description' => '',
                                                                'expression' => '',
                                                                'location' => '',
                                                                'title' => ''
                                ],
                                'members' => [
                                                                
                                ],
                                'role' => ''
                ]
        ],
        'etag' => '',
        'version' => 0
    ],
    'updateMask' => ''
  ]),
  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}}/v1/:+resource:setIamPolicy', [
  'body' => '{
  "policy": {
    "auditConfigs": [
      {
        "auditLogConfigs": [
          {
            "exemptedMembers": [],
            "logType": ""
          }
        ],
        "service": ""
      }
    ],
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  },
  "updateMask": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+resource:setIamPolicy');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'policy' => [
    'auditConfigs' => [
        [
                'auditLogConfigs' => [
                                [
                                                                'exemptedMembers' => [
                                                                                                                                
                                                                ],
                                                                'logType' => ''
                                ]
                ],
                'service' => ''
        ]
    ],
    'bindings' => [
        [
                'condition' => [
                                'description' => '',
                                'expression' => '',
                                'location' => '',
                                'title' => ''
                ],
                'members' => [
                                
                ],
                'role' => ''
        ]
    ],
    'etag' => '',
    'version' => 0
  ],
  'updateMask' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'policy' => [
    'auditConfigs' => [
        [
                'auditLogConfigs' => [
                                [
                                                                'exemptedMembers' => [
                                                                                                                                
                                                                ],
                                                                'logType' => ''
                                ]
                ],
                'service' => ''
        ]
    ],
    'bindings' => [
        [
                'condition' => [
                                'description' => '',
                                'expression' => '',
                                'location' => '',
                                'title' => ''
                ],
                'members' => [
                                
                ],
                'role' => ''
        ]
    ],
    'etag' => '',
    'version' => 0
  ],
  'updateMask' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/:+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}}/v1/:+resource:setIamPolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "policy": {
    "auditConfigs": [
      {
        "auditLogConfigs": [
          {
            "exemptedMembers": [],
            "logType": ""
          }
        ],
        "service": ""
      }
    ],
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  },
  "updateMask": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+resource:setIamPolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "policy": {
    "auditConfigs": [
      {
        "auditLogConfigs": [
          {
            "exemptedMembers": [],
            "logType": ""
          }
        ],
        "service": ""
      }
    ],
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  },
  "updateMask": ""
}'
import http.client

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

payload = "{\n  \"policy\": {\n    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1/:+resource:setIamPolicy", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+resource:setIamPolicy"

payload = {
    "policy": {
        "auditConfigs": [
            {
                "auditLogConfigs": [
                    {
                        "exemptedMembers": [],
                        "logType": ""
                    }
                ],
                "service": ""
            }
        ],
        "bindings": [
            {
                "condition": {
                    "description": "",
                    "expression": "",
                    "location": "",
                    "title": ""
                },
                "members": [],
                "role": ""
            }
        ],
        "etag": "",
        "version": 0
    },
    "updateMask": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+resource:setIamPolicy"

payload <- "{\n  \"policy\": {\n    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\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}}/v1/:+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    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\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/v1/:+resource:setIamPolicy') do |req|
  req.body = "{\n  \"policy\": {\n    \"auditConfigs\": [\n      {\n        \"auditLogConfigs\": [\n          {\n            \"exemptedMembers\": [],\n            \"logType\": \"\"\n          }\n        ],\n        \"service\": \"\"\n      }\n    ],\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  \"updateMask\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+resource:setIamPolicy";

    let payload = json!({
        "policy": json!({
            "auditConfigs": (
                json!({
                    "auditLogConfigs": (
                        json!({
                            "exemptedMembers": (),
                            "logType": ""
                        })
                    ),
                    "service": ""
                })
            ),
            "bindings": (
                json!({
                    "condition": json!({
                        "description": "",
                        "expression": "",
                        "location": "",
                        "title": ""
                    }),
                    "members": (),
                    "role": ""
                })
            ),
            "etag": "",
            "version": 0
        }),
        "updateMask": ""
    });

    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);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+resource:setIamPolicy' \
  --header 'content-type: application/json' \
  --data '{
  "policy": {
    "auditConfigs": [
      {
        "auditLogConfigs": [
          {
            "exemptedMembers": [],
            "logType": ""
          }
        ],
        "service": ""
      }
    ],
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  },
  "updateMask": ""
}'
echo '{
  "policy": {
    "auditConfigs": [
      {
        "auditLogConfigs": [
          {
            "exemptedMembers": [],
            "logType": ""
          }
        ],
        "service": ""
      }
    ],
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  },
  "updateMask": ""
}' |  \
  http POST '{{baseUrl}}/v1/:+resource:setIamPolicy' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "policy": {\n    "auditConfigs": [\n      {\n        "auditLogConfigs": [\n          {\n            "exemptedMembers": [],\n            "logType": ""\n          }\n        ],\n        "service": ""\n      }\n    ],\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  "updateMask": ""\n}' \
  --output-document \
  - '{{baseUrl}}/v1/:+resource:setIamPolicy'
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "policy": [
    "auditConfigs": [
      [
        "auditLogConfigs": [
          [
            "exemptedMembers": [],
            "logType": ""
          ]
        ],
        "service": ""
      ]
    ],
    "bindings": [
      [
        "condition": [
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        ],
        "members": [],
        "role": ""
      ]
    ],
    "etag": "",
    "version": 0
  ],
  "updateMask": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+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()
POST domains.projects.locations.registrations.testIamPermissions
{{baseUrl}}/v1/:+resource:testIamPermissions
QUERY PARAMS

resource
BODY json

{
  "permissions": []
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+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}}/v1/:+resource:testIamPermissions" {:content-type :json
                                                                             :form-params {:permissions []}})
require "http/client"

url = "{{baseUrl}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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/v1/:+resource:testIamPermissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "permissions": []
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:+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}}/v1/:+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}}/v1/:+resource:testIamPermissions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+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}}/v1/:+resource:testIamPermissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+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}}/v1/:+resource:testIamPermissions', [
  'body' => '{
  "permissions": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+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}}/v1/:+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}}/v1/:+resource:testIamPermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissions": []
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+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/v1/:+resource:testIamPermissions", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+resource:testIamPermissions"

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

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+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}}/v1/:+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/v1/:+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}}/v1/:+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);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+resource:testIamPermissions' \
  --header 'content-type: application/json' \
  --data '{
  "permissions": []
}'
echo '{
  "permissions": []
}' |  \
  http POST '{{baseUrl}}/v1/:+resource:testIamPermissions' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "permissions": []\n}' \
  --output-document \
  - '{{baseUrl}}/v1/:+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}}/v1/:+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()
POST domains.projects.locations.registrations.transfer
{{baseUrl}}/v1/:+parent/registrations:transfer
QUERY PARAMS

parent
BODY json

{
  "authorizationCode": {
    "code": ""
  },
  "contactNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}
Examples
REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/:+parent/registrations:transfer");

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  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/:+parent/registrations:transfer" {:content-type :json
                                                                               :form-params {:authorizationCode {:code ""}
                                                                                             :contactNotices []
                                                                                             :registration {:contactSettings {:adminContact {:email ""
                                                                                                                                             :faxNumber ""
                                                                                                                                             :phoneNumber ""
                                                                                                                                             :postalAddress {:addressLines []
                                                                                                                                                             :administrativeArea ""
                                                                                                                                                             :languageCode ""
                                                                                                                                                             :locality ""
                                                                                                                                                             :organization ""
                                                                                                                                                             :postalCode ""
                                                                                                                                                             :recipients []
                                                                                                                                                             :regionCode ""
                                                                                                                                                             :revision 0
                                                                                                                                                             :sortingCode ""
                                                                                                                                                             :sublocality ""}}
                                                                                                                              :privacy ""
                                                                                                                              :registrantContact {}
                                                                                                                              :technicalContact {}}
                                                                                                            :createTime ""
                                                                                                            :dnsSettings {:customDns {:dsRecords [{:algorithm ""
                                                                                                                                                   :digest ""
                                                                                                                                                   :digestType ""
                                                                                                                                                   :keyTag 0}]
                                                                                                                                      :nameServers []}
                                                                                                                          :glueRecords [{:hostName ""
                                                                                                                                         :ipv4Addresses []
                                                                                                                                         :ipv6Addresses []}]
                                                                                                                          :googleDomainsDns {:dsRecords [{}]
                                                                                                                                             :dsState ""
                                                                                                                                             :nameServers []}
                                                                                                                          :googleDomainsRedirectsDataAvailable false}
                                                                                                            :domainName ""
                                                                                                            :domainProperties []
                                                                                                            :expireTime ""
                                                                                                            :issues []
                                                                                                            :labels {}
                                                                                                            :managementSettings {:effectiveTransferLockState ""
                                                                                                                                 :preferredRenewalMethod ""
                                                                                                                                 :renewalMethod ""
                                                                                                                                 :transferLockState ""}
                                                                                                            :name ""
                                                                                                            :pendingContactSettings {}
                                                                                                            :registerFailureReason ""
                                                                                                            :state ""
                                                                                                            :supportedPrivacy []
                                                                                                            :transferFailureReason ""}
                                                                                             :validateOnly false
                                                                                             :yearlyPrice {:currencyCode ""
                                                                                                           :nanos 0
                                                                                                           :units ""}}})
require "http/client"

url = "{{baseUrl}}/v1/:+parent/registrations:transfer"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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}}/v1/:+parent/registrations:transfer"),
    Content = new StringContent("{\n  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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}}/v1/:+parent/registrations:transfer");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/v1/:+parent/registrations:transfer"

	payload := strings.NewReader("{\n  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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/v1/:+parent/registrations:transfer HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1807

{
  "authorizationCode": {
    "code": ""
  },
  "contactNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/:+parent/registrations:transfer")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/:+parent/registrations:transfer"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/:+parent/registrations:transfer")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/v1/:+parent/registrations:transfer")
  .header("content-type", "application/json")
  .body("{\n  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}")
  .asString();
const data = JSON.stringify({
  authorizationCode: {
    code: ''
  },
  contactNotices: [],
  registration: {
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    createTime: '',
    dnsSettings: {
      customDns: {
        dsRecords: [
          {
            algorithm: '',
            digest: '',
            digestType: '',
            keyTag: 0
          }
        ],
        nameServers: []
      },
      glueRecords: [
        {
          hostName: '',
          ipv4Addresses: [],
          ipv6Addresses: []
        }
      ],
      googleDomainsDns: {
        dsRecords: [
          {}
        ],
        dsState: '',
        nameServers: []
      },
      googleDomainsRedirectsDataAvailable: false
    },
    domainName: '',
    domainProperties: [],
    expireTime: '',
    issues: [],
    labels: {},
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    name: '',
    pendingContactSettings: {},
    registerFailureReason: '',
    state: '',
    supportedPrivacy: [],
    transferFailureReason: ''
  },
  validateOnly: false,
  yearlyPrice: {
    currencyCode: '',
    nanos: 0,
    units: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/:+parent/registrations:transfer');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+parent/registrations:transfer',
  headers: {'content-type': 'application/json'},
  data: {
    authorizationCode: {code: ''},
    contactNotices: [],
    registration: {
      contactSettings: {
        adminContact: {
          email: '',
          faxNumber: '',
          phoneNumber: '',
          postalAddress: {
            addressLines: [],
            administrativeArea: '',
            languageCode: '',
            locality: '',
            organization: '',
            postalCode: '',
            recipients: [],
            regionCode: '',
            revision: 0,
            sortingCode: '',
            sublocality: ''
          }
        },
        privacy: '',
        registrantContact: {},
        technicalContact: {}
      },
      createTime: '',
      dnsSettings: {
        customDns: {
          dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
          nameServers: []
        },
        glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
        googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
        googleDomainsRedirectsDataAvailable: false
      },
      domainName: '',
      domainProperties: [],
      expireTime: '',
      issues: [],
      labels: {},
      managementSettings: {
        effectiveTransferLockState: '',
        preferredRenewalMethod: '',
        renewalMethod: '',
        transferLockState: ''
      },
      name: '',
      pendingContactSettings: {},
      registerFailureReason: '',
      state: '',
      supportedPrivacy: [],
      transferFailureReason: ''
    },
    validateOnly: false,
    yearlyPrice: {currencyCode: '', nanos: 0, units: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/v1/:+parent/registrations:transfer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizationCode":{"code":""},"contactNotices":[],"registration":{"contactSettings":{"adminContact":{"email":"","faxNumber":"","phoneNumber":"","postalAddress":{"addressLines":[],"administrativeArea":"","languageCode":"","locality":"","organization":"","postalCode":"","recipients":[],"regionCode":"","revision":0,"sortingCode":"","sublocality":""}},"privacy":"","registrantContact":{},"technicalContact":{}},"createTime":"","dnsSettings":{"customDns":{"dsRecords":[{"algorithm":"","digest":"","digestType":"","keyTag":0}],"nameServers":[]},"glueRecords":[{"hostName":"","ipv4Addresses":[],"ipv6Addresses":[]}],"googleDomainsDns":{"dsRecords":[{}],"dsState":"","nameServers":[]},"googleDomainsRedirectsDataAvailable":false},"domainName":"","domainProperties":[],"expireTime":"","issues":[],"labels":{},"managementSettings":{"effectiveTransferLockState":"","preferredRenewalMethod":"","renewalMethod":"","transferLockState":""},"name":"","pendingContactSettings":{},"registerFailureReason":"","state":"","supportedPrivacy":[],"transferFailureReason":""},"validateOnly":false,"yearlyPrice":{"currencyCode":"","nanos":0,"units":""}}'
};

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}}/v1/:+parent/registrations:transfer',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authorizationCode": {\n    "code": ""\n  },\n  "contactNotices": [],\n  "registration": {\n    "contactSettings": {\n      "adminContact": {\n        "email": "",\n        "faxNumber": "",\n        "phoneNumber": "",\n        "postalAddress": {\n          "addressLines": [],\n          "administrativeArea": "",\n          "languageCode": "",\n          "locality": "",\n          "organization": "",\n          "postalCode": "",\n          "recipients": [],\n          "regionCode": "",\n          "revision": 0,\n          "sortingCode": "",\n          "sublocality": ""\n        }\n      },\n      "privacy": "",\n      "registrantContact": {},\n      "technicalContact": {}\n    },\n    "createTime": "",\n    "dnsSettings": {\n      "customDns": {\n        "dsRecords": [\n          {\n            "algorithm": "",\n            "digest": "",\n            "digestType": "",\n            "keyTag": 0\n          }\n        ],\n        "nameServers": []\n      },\n      "glueRecords": [\n        {\n          "hostName": "",\n          "ipv4Addresses": [],\n          "ipv6Addresses": []\n        }\n      ],\n      "googleDomainsDns": {\n        "dsRecords": [\n          {}\n        ],\n        "dsState": "",\n        "nameServers": []\n      },\n      "googleDomainsRedirectsDataAvailable": false\n    },\n    "domainName": "",\n    "domainProperties": [],\n    "expireTime": "",\n    "issues": [],\n    "labels": {},\n    "managementSettings": {\n      "effectiveTransferLockState": "",\n      "preferredRenewalMethod": "",\n      "renewalMethod": "",\n      "transferLockState": ""\n    },\n    "name": "",\n    "pendingContactSettings": {},\n    "registerFailureReason": "",\n    "state": "",\n    "supportedPrivacy": [],\n    "transferFailureReason": ""\n  },\n  "validateOnly": false,\n  "yearlyPrice": {\n    "currencyCode": "",\n    "nanos": 0,\n    "units": ""\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  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/:+parent/registrations:transfer")
  .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/v1/:+parent/registrations:transfer',
  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({
  authorizationCode: {code: ''},
  contactNotices: [],
  registration: {
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    createTime: '',
    dnsSettings: {
      customDns: {
        dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
        nameServers: []
      },
      glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
      googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
      googleDomainsRedirectsDataAvailable: false
    },
    domainName: '',
    domainProperties: [],
    expireTime: '',
    issues: [],
    labels: {},
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    name: '',
    pendingContactSettings: {},
    registerFailureReason: '',
    state: '',
    supportedPrivacy: [],
    transferFailureReason: ''
  },
  validateOnly: false,
  yearlyPrice: {currencyCode: '', nanos: 0, units: ''}
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/:+parent/registrations:transfer',
  headers: {'content-type': 'application/json'},
  body: {
    authorizationCode: {code: ''},
    contactNotices: [],
    registration: {
      contactSettings: {
        adminContact: {
          email: '',
          faxNumber: '',
          phoneNumber: '',
          postalAddress: {
            addressLines: [],
            administrativeArea: '',
            languageCode: '',
            locality: '',
            organization: '',
            postalCode: '',
            recipients: [],
            regionCode: '',
            revision: 0,
            sortingCode: '',
            sublocality: ''
          }
        },
        privacy: '',
        registrantContact: {},
        technicalContact: {}
      },
      createTime: '',
      dnsSettings: {
        customDns: {
          dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
          nameServers: []
        },
        glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
        googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
        googleDomainsRedirectsDataAvailable: false
      },
      domainName: '',
      domainProperties: [],
      expireTime: '',
      issues: [],
      labels: {},
      managementSettings: {
        effectiveTransferLockState: '',
        preferredRenewalMethod: '',
        renewalMethod: '',
        transferLockState: ''
      },
      name: '',
      pendingContactSettings: {},
      registerFailureReason: '',
      state: '',
      supportedPrivacy: [],
      transferFailureReason: ''
    },
    validateOnly: false,
    yearlyPrice: {currencyCode: '', nanos: 0, units: ''}
  },
  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}}/v1/:+parent/registrations:transfer');

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

req.type('json');
req.send({
  authorizationCode: {
    code: ''
  },
  contactNotices: [],
  registration: {
    contactSettings: {
      adminContact: {
        email: '',
        faxNumber: '',
        phoneNumber: '',
        postalAddress: {
          addressLines: [],
          administrativeArea: '',
          languageCode: '',
          locality: '',
          organization: '',
          postalCode: '',
          recipients: [],
          regionCode: '',
          revision: 0,
          sortingCode: '',
          sublocality: ''
        }
      },
      privacy: '',
      registrantContact: {},
      technicalContact: {}
    },
    createTime: '',
    dnsSettings: {
      customDns: {
        dsRecords: [
          {
            algorithm: '',
            digest: '',
            digestType: '',
            keyTag: 0
          }
        ],
        nameServers: []
      },
      glueRecords: [
        {
          hostName: '',
          ipv4Addresses: [],
          ipv6Addresses: []
        }
      ],
      googleDomainsDns: {
        dsRecords: [
          {}
        ],
        dsState: '',
        nameServers: []
      },
      googleDomainsRedirectsDataAvailable: false
    },
    domainName: '',
    domainProperties: [],
    expireTime: '',
    issues: [],
    labels: {},
    managementSettings: {
      effectiveTransferLockState: '',
      preferredRenewalMethod: '',
      renewalMethod: '',
      transferLockState: ''
    },
    name: '',
    pendingContactSettings: {},
    registerFailureReason: '',
    state: '',
    supportedPrivacy: [],
    transferFailureReason: ''
  },
  validateOnly: false,
  yearlyPrice: {
    currencyCode: '',
    nanos: 0,
    units: ''
  }
});

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}}/v1/:+parent/registrations:transfer',
  headers: {'content-type': 'application/json'},
  data: {
    authorizationCode: {code: ''},
    contactNotices: [],
    registration: {
      contactSettings: {
        adminContact: {
          email: '',
          faxNumber: '',
          phoneNumber: '',
          postalAddress: {
            addressLines: [],
            administrativeArea: '',
            languageCode: '',
            locality: '',
            organization: '',
            postalCode: '',
            recipients: [],
            regionCode: '',
            revision: 0,
            sortingCode: '',
            sublocality: ''
          }
        },
        privacy: '',
        registrantContact: {},
        technicalContact: {}
      },
      createTime: '',
      dnsSettings: {
        customDns: {
          dsRecords: [{algorithm: '', digest: '', digestType: '', keyTag: 0}],
          nameServers: []
        },
        glueRecords: [{hostName: '', ipv4Addresses: [], ipv6Addresses: []}],
        googleDomainsDns: {dsRecords: [{}], dsState: '', nameServers: []},
        googleDomainsRedirectsDataAvailable: false
      },
      domainName: '',
      domainProperties: [],
      expireTime: '',
      issues: [],
      labels: {},
      managementSettings: {
        effectiveTransferLockState: '',
        preferredRenewalMethod: '',
        renewalMethod: '',
        transferLockState: ''
      },
      name: '',
      pendingContactSettings: {},
      registerFailureReason: '',
      state: '',
      supportedPrivacy: [],
      transferFailureReason: ''
    },
    validateOnly: false,
    yearlyPrice: {currencyCode: '', nanos: 0, units: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/:+parent/registrations:transfer';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizationCode":{"code":""},"contactNotices":[],"registration":{"contactSettings":{"adminContact":{"email":"","faxNumber":"","phoneNumber":"","postalAddress":{"addressLines":[],"administrativeArea":"","languageCode":"","locality":"","organization":"","postalCode":"","recipients":[],"regionCode":"","revision":0,"sortingCode":"","sublocality":""}},"privacy":"","registrantContact":{},"technicalContact":{}},"createTime":"","dnsSettings":{"customDns":{"dsRecords":[{"algorithm":"","digest":"","digestType":"","keyTag":0}],"nameServers":[]},"glueRecords":[{"hostName":"","ipv4Addresses":[],"ipv6Addresses":[]}],"googleDomainsDns":{"dsRecords":[{}],"dsState":"","nameServers":[]},"googleDomainsRedirectsDataAvailable":false},"domainName":"","domainProperties":[],"expireTime":"","issues":[],"labels":{},"managementSettings":{"effectiveTransferLockState":"","preferredRenewalMethod":"","renewalMethod":"","transferLockState":""},"name":"","pendingContactSettings":{},"registerFailureReason":"","state":"","supportedPrivacy":[],"transferFailureReason":""},"validateOnly":false,"yearlyPrice":{"currencyCode":"","nanos":0,"units":""}}'
};

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 = @{ @"authorizationCode": @{ @"code": @"" },
                              @"contactNotices": @[  ],
                              @"registration": @{ @"contactSettings": @{ @"adminContact": @{ @"email": @"", @"faxNumber": @"", @"phoneNumber": @"", @"postalAddress": @{ @"addressLines": @[  ], @"administrativeArea": @"", @"languageCode": @"", @"locality": @"", @"organization": @"", @"postalCode": @"", @"recipients": @[  ], @"regionCode": @"", @"revision": @0, @"sortingCode": @"", @"sublocality": @"" } }, @"privacy": @"", @"registrantContact": @{  }, @"technicalContact": @{  } }, @"createTime": @"", @"dnsSettings": @{ @"customDns": @{ @"dsRecords": @[ @{ @"algorithm": @"", @"digest": @"", @"digestType": @"", @"keyTag": @0 } ], @"nameServers": @[  ] }, @"glueRecords": @[ @{ @"hostName": @"", @"ipv4Addresses": @[  ], @"ipv6Addresses": @[  ] } ], @"googleDomainsDns": @{ @"dsRecords": @[ @{  } ], @"dsState": @"", @"nameServers": @[  ] }, @"googleDomainsRedirectsDataAvailable": @NO }, @"domainName": @"", @"domainProperties": @[  ], @"expireTime": @"", @"issues": @[  ], @"labels": @{  }, @"managementSettings": @{ @"effectiveTransferLockState": @"", @"preferredRenewalMethod": @"", @"renewalMethod": @"", @"transferLockState": @"" }, @"name": @"", @"pendingContactSettings": @{  }, @"registerFailureReason": @"", @"state": @"", @"supportedPrivacy": @[  ], @"transferFailureReason": @"" },
                              @"validateOnly": @NO,
                              @"yearlyPrice": @{ @"currencyCode": @"", @"nanos": @0, @"units": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/:+parent/registrations:transfer"]
                                                       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}}/v1/:+parent/registrations:transfer" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/v1/:+parent/registrations:transfer",
  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([
    'authorizationCode' => [
        'code' => ''
    ],
    'contactNotices' => [
        
    ],
    'registration' => [
        'contactSettings' => [
                'adminContact' => [
                                'email' => '',
                                'faxNumber' => '',
                                'phoneNumber' => '',
                                'postalAddress' => [
                                                                'addressLines' => [
                                                                                                                                
                                                                ],
                                                                'administrativeArea' => '',
                                                                'languageCode' => '',
                                                                'locality' => '',
                                                                'organization' => '',
                                                                'postalCode' => '',
                                                                'recipients' => [
                                                                                                                                
                                                                ],
                                                                'regionCode' => '',
                                                                'revision' => 0,
                                                                'sortingCode' => '',
                                                                'sublocality' => ''
                                ]
                ],
                'privacy' => '',
                'registrantContact' => [
                                
                ],
                'technicalContact' => [
                                
                ]
        ],
        'createTime' => '',
        'dnsSettings' => [
                'customDns' => [
                                'dsRecords' => [
                                                                [
                                                                                                                                'algorithm' => '',
                                                                                                                                'digest' => '',
                                                                                                                                'digestType' => '',
                                                                                                                                'keyTag' => 0
                                                                ]
                                ],
                                'nameServers' => [
                                                                
                                ]
                ],
                'glueRecords' => [
                                [
                                                                'hostName' => '',
                                                                'ipv4Addresses' => [
                                                                                                                                
                                                                ],
                                                                'ipv6Addresses' => [
                                                                                                                                
                                                                ]
                                ]
                ],
                'googleDomainsDns' => [
                                'dsRecords' => [
                                                                [
                                                                                                                                
                                                                ]
                                ],
                                'dsState' => '',
                                'nameServers' => [
                                                                
                                ]
                ],
                'googleDomainsRedirectsDataAvailable' => null
        ],
        'domainName' => '',
        'domainProperties' => [
                
        ],
        'expireTime' => '',
        'issues' => [
                
        ],
        'labels' => [
                
        ],
        'managementSettings' => [
                'effectiveTransferLockState' => '',
                'preferredRenewalMethod' => '',
                'renewalMethod' => '',
                'transferLockState' => ''
        ],
        'name' => '',
        'pendingContactSettings' => [
                
        ],
        'registerFailureReason' => '',
        'state' => '',
        'supportedPrivacy' => [
                
        ],
        'transferFailureReason' => ''
    ],
    'validateOnly' => null,
    'yearlyPrice' => [
        'currencyCode' => '',
        'nanos' => 0,
        'units' => ''
    ]
  ]),
  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}}/v1/:+parent/registrations:transfer', [
  'body' => '{
  "authorizationCode": {
    "code": ""
  },
  "contactNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/v1/:+parent/registrations:transfer');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authorizationCode' => [
    'code' => ''
  ],
  'contactNotices' => [
    
  ],
  'registration' => [
    'contactSettings' => [
        'adminContact' => [
                'email' => '',
                'faxNumber' => '',
                'phoneNumber' => '',
                'postalAddress' => [
                                'addressLines' => [
                                                                
                                ],
                                'administrativeArea' => '',
                                'languageCode' => '',
                                'locality' => '',
                                'organization' => '',
                                'postalCode' => '',
                                'recipients' => [
                                                                
                                ],
                                'regionCode' => '',
                                'revision' => 0,
                                'sortingCode' => '',
                                'sublocality' => ''
                ]
        ],
        'privacy' => '',
        'registrantContact' => [
                
        ],
        'technicalContact' => [
                
        ]
    ],
    'createTime' => '',
    'dnsSettings' => [
        'customDns' => [
                'dsRecords' => [
                                [
                                                                'algorithm' => '',
                                                                'digest' => '',
                                                                'digestType' => '',
                                                                'keyTag' => 0
                                ]
                ],
                'nameServers' => [
                                
                ]
        ],
        'glueRecords' => [
                [
                                'hostName' => '',
                                'ipv4Addresses' => [
                                                                
                                ],
                                'ipv6Addresses' => [
                                                                
                                ]
                ]
        ],
        'googleDomainsDns' => [
                'dsRecords' => [
                                [
                                                                
                                ]
                ],
                'dsState' => '',
                'nameServers' => [
                                
                ]
        ],
        'googleDomainsRedirectsDataAvailable' => null
    ],
    'domainName' => '',
    'domainProperties' => [
        
    ],
    'expireTime' => '',
    'issues' => [
        
    ],
    'labels' => [
        
    ],
    'managementSettings' => [
        'effectiveTransferLockState' => '',
        'preferredRenewalMethod' => '',
        'renewalMethod' => '',
        'transferLockState' => ''
    ],
    'name' => '',
    'pendingContactSettings' => [
        
    ],
    'registerFailureReason' => '',
    'state' => '',
    'supportedPrivacy' => [
        
    ],
    'transferFailureReason' => ''
  ],
  'validateOnly' => null,
  'yearlyPrice' => [
    'currencyCode' => '',
    'nanos' => 0,
    'units' => ''
  ]
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'authorizationCode' => [
    'code' => ''
  ],
  'contactNotices' => [
    
  ],
  'registration' => [
    'contactSettings' => [
        'adminContact' => [
                'email' => '',
                'faxNumber' => '',
                'phoneNumber' => '',
                'postalAddress' => [
                                'addressLines' => [
                                                                
                                ],
                                'administrativeArea' => '',
                                'languageCode' => '',
                                'locality' => '',
                                'organization' => '',
                                'postalCode' => '',
                                'recipients' => [
                                                                
                                ],
                                'regionCode' => '',
                                'revision' => 0,
                                'sortingCode' => '',
                                'sublocality' => ''
                ]
        ],
        'privacy' => '',
        'registrantContact' => [
                
        ],
        'technicalContact' => [
                
        ]
    ],
    'createTime' => '',
    'dnsSettings' => [
        'customDns' => [
                'dsRecords' => [
                                [
                                                                'algorithm' => '',
                                                                'digest' => '',
                                                                'digestType' => '',
                                                                'keyTag' => 0
                                ]
                ],
                'nameServers' => [
                                
                ]
        ],
        'glueRecords' => [
                [
                                'hostName' => '',
                                'ipv4Addresses' => [
                                                                
                                ],
                                'ipv6Addresses' => [
                                                                
                                ]
                ]
        ],
        'googleDomainsDns' => [
                'dsRecords' => [
                                [
                                                                
                                ]
                ],
                'dsState' => '',
                'nameServers' => [
                                
                ]
        ],
        'googleDomainsRedirectsDataAvailable' => null
    ],
    'domainName' => '',
    'domainProperties' => [
        
    ],
    'expireTime' => '',
    'issues' => [
        
    ],
    'labels' => [
        
    ],
    'managementSettings' => [
        'effectiveTransferLockState' => '',
        'preferredRenewalMethod' => '',
        'renewalMethod' => '',
        'transferLockState' => ''
    ],
    'name' => '',
    'pendingContactSettings' => [
        
    ],
    'registerFailureReason' => '',
    'state' => '',
    'supportedPrivacy' => [
        
    ],
    'transferFailureReason' => ''
  ],
  'validateOnly' => null,
  'yearlyPrice' => [
    'currencyCode' => '',
    'nanos' => 0,
    'units' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/:+parent/registrations:transfer');
$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}}/v1/:+parent/registrations:transfer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizationCode": {
    "code": ""
  },
  "contactNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/:+parent/registrations:transfer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizationCode": {
    "code": ""
  },
  "contactNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}'
import http.client

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

payload = "{\n  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1/:+parent/registrations:transfer", payload, headers)

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

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

url = "{{baseUrl}}/v1/:+parent/registrations:transfer"

payload = {
    "authorizationCode": { "code": "" },
    "contactNotices": [],
    "registration": {
        "contactSettings": {
            "adminContact": {
                "email": "",
                "faxNumber": "",
                "phoneNumber": "",
                "postalAddress": {
                    "addressLines": [],
                    "administrativeArea": "",
                    "languageCode": "",
                    "locality": "",
                    "organization": "",
                    "postalCode": "",
                    "recipients": [],
                    "regionCode": "",
                    "revision": 0,
                    "sortingCode": "",
                    "sublocality": ""
                }
            },
            "privacy": "",
            "registrantContact": {},
            "technicalContact": {}
        },
        "createTime": "",
        "dnsSettings": {
            "customDns": {
                "dsRecords": [
                    {
                        "algorithm": "",
                        "digest": "",
                        "digestType": "",
                        "keyTag": 0
                    }
                ],
                "nameServers": []
            },
            "glueRecords": [
                {
                    "hostName": "",
                    "ipv4Addresses": [],
                    "ipv6Addresses": []
                }
            ],
            "googleDomainsDns": {
                "dsRecords": [{}],
                "dsState": "",
                "nameServers": []
            },
            "googleDomainsRedirectsDataAvailable": False
        },
        "domainName": "",
        "domainProperties": [],
        "expireTime": "",
        "issues": [],
        "labels": {},
        "managementSettings": {
            "effectiveTransferLockState": "",
            "preferredRenewalMethod": "",
            "renewalMethod": "",
            "transferLockState": ""
        },
        "name": "",
        "pendingContactSettings": {},
        "registerFailureReason": "",
        "state": "",
        "supportedPrivacy": [],
        "transferFailureReason": ""
    },
    "validateOnly": False,
    "yearlyPrice": {
        "currencyCode": "",
        "nanos": 0,
        "units": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/v1/:+parent/registrations:transfer"

payload <- "{\n  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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}}/v1/:+parent/registrations:transfer")

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  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\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/v1/:+parent/registrations:transfer') do |req|
  req.body = "{\n  \"authorizationCode\": {\n    \"code\": \"\"\n  },\n  \"contactNotices\": [],\n  \"registration\": {\n    \"contactSettings\": {\n      \"adminContact\": {\n        \"email\": \"\",\n        \"faxNumber\": \"\",\n        \"phoneNumber\": \"\",\n        \"postalAddress\": {\n          \"addressLines\": [],\n          \"administrativeArea\": \"\",\n          \"languageCode\": \"\",\n          \"locality\": \"\",\n          \"organization\": \"\",\n          \"postalCode\": \"\",\n          \"recipients\": [],\n          \"regionCode\": \"\",\n          \"revision\": 0,\n          \"sortingCode\": \"\",\n          \"sublocality\": \"\"\n        }\n      },\n      \"privacy\": \"\",\n      \"registrantContact\": {},\n      \"technicalContact\": {}\n    },\n    \"createTime\": \"\",\n    \"dnsSettings\": {\n      \"customDns\": {\n        \"dsRecords\": [\n          {\n            \"algorithm\": \"\",\n            \"digest\": \"\",\n            \"digestType\": \"\",\n            \"keyTag\": 0\n          }\n        ],\n        \"nameServers\": []\n      },\n      \"glueRecords\": [\n        {\n          \"hostName\": \"\",\n          \"ipv4Addresses\": [],\n          \"ipv6Addresses\": []\n        }\n      ],\n      \"googleDomainsDns\": {\n        \"dsRecords\": [\n          {}\n        ],\n        \"dsState\": \"\",\n        \"nameServers\": []\n      },\n      \"googleDomainsRedirectsDataAvailable\": false\n    },\n    \"domainName\": \"\",\n    \"domainProperties\": [],\n    \"expireTime\": \"\",\n    \"issues\": [],\n    \"labels\": {},\n    \"managementSettings\": {\n      \"effectiveTransferLockState\": \"\",\n      \"preferredRenewalMethod\": \"\",\n      \"renewalMethod\": \"\",\n      \"transferLockState\": \"\"\n    },\n    \"name\": \"\",\n    \"pendingContactSettings\": {},\n    \"registerFailureReason\": \"\",\n    \"state\": \"\",\n    \"supportedPrivacy\": [],\n    \"transferFailureReason\": \"\"\n  },\n  \"validateOnly\": false,\n  \"yearlyPrice\": {\n    \"currencyCode\": \"\",\n    \"nanos\": 0,\n    \"units\": \"\"\n  }\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/:+parent/registrations:transfer";

    let payload = json!({
        "authorizationCode": json!({"code": ""}),
        "contactNotices": (),
        "registration": json!({
            "contactSettings": json!({
                "adminContact": json!({
                    "email": "",
                    "faxNumber": "",
                    "phoneNumber": "",
                    "postalAddress": json!({
                        "addressLines": (),
                        "administrativeArea": "",
                        "languageCode": "",
                        "locality": "",
                        "organization": "",
                        "postalCode": "",
                        "recipients": (),
                        "regionCode": "",
                        "revision": 0,
                        "sortingCode": "",
                        "sublocality": ""
                    })
                }),
                "privacy": "",
                "registrantContact": json!({}),
                "technicalContact": json!({})
            }),
            "createTime": "",
            "dnsSettings": json!({
                "customDns": json!({
                    "dsRecords": (
                        json!({
                            "algorithm": "",
                            "digest": "",
                            "digestType": "",
                            "keyTag": 0
                        })
                    ),
                    "nameServers": ()
                }),
                "glueRecords": (
                    json!({
                        "hostName": "",
                        "ipv4Addresses": (),
                        "ipv6Addresses": ()
                    })
                ),
                "googleDomainsDns": json!({
                    "dsRecords": (json!({})),
                    "dsState": "",
                    "nameServers": ()
                }),
                "googleDomainsRedirectsDataAvailable": false
            }),
            "domainName": "",
            "domainProperties": (),
            "expireTime": "",
            "issues": (),
            "labels": json!({}),
            "managementSettings": json!({
                "effectiveTransferLockState": "",
                "preferredRenewalMethod": "",
                "renewalMethod": "",
                "transferLockState": ""
            }),
            "name": "",
            "pendingContactSettings": json!({}),
            "registerFailureReason": "",
            "state": "",
            "supportedPrivacy": (),
            "transferFailureReason": ""
        }),
        "validateOnly": false,
        "yearlyPrice": json!({
            "currencyCode": "",
            "nanos": 0,
            "units": ""
        })
    });

    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);
}
curl --request POST \
  --url '{{baseUrl}}/v1/:+parent/registrations:transfer' \
  --header 'content-type: application/json' \
  --data '{
  "authorizationCode": {
    "code": ""
  },
  "contactNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}'
echo '{
  "authorizationCode": {
    "code": ""
  },
  "contactNotices": [],
  "registration": {
    "contactSettings": {
      "adminContact": {
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": {
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        }
      },
      "privacy": "",
      "registrantContact": {},
      "technicalContact": {}
    },
    "createTime": "",
    "dnsSettings": {
      "customDns": {
        "dsRecords": [
          {
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          }
        ],
        "nameServers": []
      },
      "glueRecords": [
        {
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        }
      ],
      "googleDomainsDns": {
        "dsRecords": [
          {}
        ],
        "dsState": "",
        "nameServers": []
      },
      "googleDomainsRedirectsDataAvailable": false
    },
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": {},
    "managementSettings": {
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    },
    "name": "",
    "pendingContactSettings": {},
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  },
  "validateOnly": false,
  "yearlyPrice": {
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  }
}' |  \
  http POST '{{baseUrl}}/v1/:+parent/registrations:transfer' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authorizationCode": {\n    "code": ""\n  },\n  "contactNotices": [],\n  "registration": {\n    "contactSettings": {\n      "adminContact": {\n        "email": "",\n        "faxNumber": "",\n        "phoneNumber": "",\n        "postalAddress": {\n          "addressLines": [],\n          "administrativeArea": "",\n          "languageCode": "",\n          "locality": "",\n          "organization": "",\n          "postalCode": "",\n          "recipients": [],\n          "regionCode": "",\n          "revision": 0,\n          "sortingCode": "",\n          "sublocality": ""\n        }\n      },\n      "privacy": "",\n      "registrantContact": {},\n      "technicalContact": {}\n    },\n    "createTime": "",\n    "dnsSettings": {\n      "customDns": {\n        "dsRecords": [\n          {\n            "algorithm": "",\n            "digest": "",\n            "digestType": "",\n            "keyTag": 0\n          }\n        ],\n        "nameServers": []\n      },\n      "glueRecords": [\n        {\n          "hostName": "",\n          "ipv4Addresses": [],\n          "ipv6Addresses": []\n        }\n      ],\n      "googleDomainsDns": {\n        "dsRecords": [\n          {}\n        ],\n        "dsState": "",\n        "nameServers": []\n      },\n      "googleDomainsRedirectsDataAvailable": false\n    },\n    "domainName": "",\n    "domainProperties": [],\n    "expireTime": "",\n    "issues": [],\n    "labels": {},\n    "managementSettings": {\n      "effectiveTransferLockState": "",\n      "preferredRenewalMethod": "",\n      "renewalMethod": "",\n      "transferLockState": ""\n    },\n    "name": "",\n    "pendingContactSettings": {},\n    "registerFailureReason": "",\n    "state": "",\n    "supportedPrivacy": [],\n    "transferFailureReason": ""\n  },\n  "validateOnly": false,\n  "yearlyPrice": {\n    "currencyCode": "",\n    "nanos": 0,\n    "units": ""\n  }\n}' \
  --output-document \
  - '{{baseUrl}}/v1/:+parent/registrations:transfer'
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authorizationCode": ["code": ""],
  "contactNotices": [],
  "registration": [
    "contactSettings": [
      "adminContact": [
        "email": "",
        "faxNumber": "",
        "phoneNumber": "",
        "postalAddress": [
          "addressLines": [],
          "administrativeArea": "",
          "languageCode": "",
          "locality": "",
          "organization": "",
          "postalCode": "",
          "recipients": [],
          "regionCode": "",
          "revision": 0,
          "sortingCode": "",
          "sublocality": ""
        ]
      ],
      "privacy": "",
      "registrantContact": [],
      "technicalContact": []
    ],
    "createTime": "",
    "dnsSettings": [
      "customDns": [
        "dsRecords": [
          [
            "algorithm": "",
            "digest": "",
            "digestType": "",
            "keyTag": 0
          ]
        ],
        "nameServers": []
      ],
      "glueRecords": [
        [
          "hostName": "",
          "ipv4Addresses": [],
          "ipv6Addresses": []
        ]
      ],
      "googleDomainsDns": [
        "dsRecords": [[]],
        "dsState": "",
        "nameServers": []
      ],
      "googleDomainsRedirectsDataAvailable": false
    ],
    "domainName": "",
    "domainProperties": [],
    "expireTime": "",
    "issues": [],
    "labels": [],
    "managementSettings": [
      "effectiveTransferLockState": "",
      "preferredRenewalMethod": "",
      "renewalMethod": "",
      "transferLockState": ""
    ],
    "name": "",
    "pendingContactSettings": [],
    "registerFailureReason": "",
    "state": "",
    "supportedPrivacy": [],
    "transferFailureReason": ""
  ],
  "validateOnly": false,
  "yearlyPrice": [
    "currencyCode": "",
    "nanos": 0,
    "units": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/:+parent/registrations:transfer")! 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()