CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/:blogId")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId"

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

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId"

	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/v3/blogs/:blogId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/blogs/:blogId'};

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

const url = '{{baseUrl}}/v3/blogs/:blogId';
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}}/v3/blogs/:blogId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/:blogId');

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}}/v3/blogs/:blogId'};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId';
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}}/v3/blogs/:blogId"]
                                                       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}}/v3/blogs/:blogId" in

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

 "{{baseUrl}}/v3/blogs/:blogId",
  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}}/v3/blogs/:blogId');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/:blogId")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId")

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/v3/blogs/:blogId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v3/blogs/:blogId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/byurl?url=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/byurl" {:query-params {:url ""}})

require "http/client"

url = "{{baseUrl}}/v3/blogs/byurl?url="

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}}/v3/blogs/byurl?url="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/byurl?url=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/byurl?url="

	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/v3/blogs/byurl?url= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/blogs/byurl?url=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/byurl?url="))
    .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}}/v3/blogs/byurl?url=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/blogs/byurl?url=")
  .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}}/v3/blogs/byurl?url=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/blogs/byurl',
  params: {url: ''}
};

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

const url = '{{baseUrl}}/v3/blogs/byurl?url=';
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}}/v3/blogs/byurl?url=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/byurl?url=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/byurl?url=',
  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}}/v3/blogs/byurl',
  qs: {url: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/byurl');

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

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}}/v3/blogs/byurl',
  params: {url: ''}
};

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

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

const url = '{{baseUrl}}/v3/blogs/byurl?url=';
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}}/v3/blogs/byurl?url="]
                                                       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}}/v3/blogs/byurl?url=" in

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

 "{{baseUrl}}/v3/blogs/byurl?url=",
  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}}/v3/blogs/byurl?url=');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/byurl');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/byurl');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'url' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/byurl?url=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/byurl?url=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/byurl?url=")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/byurl"

querystring = {"url":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/byurl"

queryString <- list(url = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/byurl?url=")

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/v3/blogs/byurl') do |req|
  req.params['url'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/byurl";

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

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/v3/blogs/byurl?url='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v3/blogs/byurl?url='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/byurl?url=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/users/:userId/blogs");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/users/:userId/blogs")

require "http/client"

url = "{{baseUrl}}/v3/users/:userId/blogs"

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

var client = new RestClient("{{baseUrl}}/v3/users/:userId/blogs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/users/:userId/blogs"

	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/v3/users/:userId/blogs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/users/:userId/blogs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/users/:userId/blogs")
  .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}}/v3/users/:userId/blogs');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/users/:userId/blogs'};

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

const url = '{{baseUrl}}/v3/users/:userId/blogs';
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}}/v3/users/:userId/blogs',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/users/:userId/blogs")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/users/:userId/blogs');

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}}/v3/users/:userId/blogs'};

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

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

const url = '{{baseUrl}}/v3/users/:userId/blogs';
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}}/v3/users/:userId/blogs"]
                                                       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}}/v3/users/:userId/blogs" in

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

 "{{baseUrl}}/v3/users/:userId/blogs",
  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}}/v3/users/:userId/blogs');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/users/:userId/blogs');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v3/users/:userId/blogs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/users/:userId/blogs' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/users/:userId/blogs' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/users/:userId/blogs")

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

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

import requests

url = "{{baseUrl}}/v3/users/:userId/blogs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/users/:userId/blogs"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/users/:userId/blogs")

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/v3/users/:userId/blogs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/users/:userId/blogs";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v3/users/:userId/blogs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/users/:userId/blogs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/users/:userId/blogs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/users/:userId/blogs/:blogId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/users/:userId/blogs/:blogId")

require "http/client"

url = "{{baseUrl}}/v3/users/:userId/blogs/:blogId"

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

var client = new RestClient("{{baseUrl}}/v3/users/:userId/blogs/:blogId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/users/:userId/blogs/:blogId"

	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/v3/users/:userId/blogs/:blogId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/users/:userId/blogs/:blogId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/users/:userId/blogs/:blogId"))
    .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}}/v3/users/:userId/blogs/:blogId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/users/:userId/blogs/:blogId")
  .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}}/v3/users/:userId/blogs/:blogId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/users/:userId/blogs/:blogId'
};

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

const url = '{{baseUrl}}/v3/users/:userId/blogs/:blogId';
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}}/v3/users/:userId/blogs/:blogId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/users/:userId/blogs/:blogId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/users/:userId/blogs/:blogId',
  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}}/v3/users/:userId/blogs/:blogId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/users/:userId/blogs/:blogId');

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}}/v3/users/:userId/blogs/:blogId'
};

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

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

const url = '{{baseUrl}}/v3/users/:userId/blogs/:blogId';
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}}/v3/users/:userId/blogs/:blogId"]
                                                       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}}/v3/users/:userId/blogs/:blogId" in

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

 "{{baseUrl}}/v3/users/:userId/blogs/:blogId",
  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}}/v3/users/:userId/blogs/:blogId');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/users/:userId/blogs/:blogId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v3/users/:userId/blogs/:blogId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/users/:userId/blogs/:blogId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/users/:userId/blogs/:blogId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/users/:userId/blogs/:blogId")

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

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

import requests

url = "{{baseUrl}}/v3/users/:userId/blogs/:blogId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/users/:userId/blogs/:blogId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/users/:userId/blogs/:blogId")

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/v3/users/:userId/blogs/:blogId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/users/:userId/blogs/:blogId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v3/users/:userId/blogs/:blogId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/users/:userId/blogs/:blogId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/users/:userId/blogs/:blogId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve"

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

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

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

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

}

POST /baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve');

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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/approve")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"

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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"

	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/v3/blogs/:blogId/posts/:postId/comments/:commentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"))
    .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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")
  .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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId';
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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId',
  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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId');

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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId';
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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"]
                                                       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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId",
  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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")

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/v3/blogs/:blogId/posts/:postId/comments/:commentId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"

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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"

	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/v3/blogs/:blogId/posts/:postId/comments/:commentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"))
    .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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")
  .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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId';
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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId',
  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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId');

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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId';
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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"]
                                                       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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId",
  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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")

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/v3/blogs/:blogId/posts/:postId/comments/:commentId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments"

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}}/v3/blogs/:blogId/posts/:postId/comments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments"

	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/v3/blogs/:blogId/posts/:postId/comments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments"))
    .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}}/v3/blogs/:blogId/posts/:postId/comments")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments")
  .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}}/v3/blogs/:blogId/posts/:postId/comments');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments';
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}}/v3/blogs/:blogId/posts/:postId/comments',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/:postId/comments',
  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}}/v3/blogs/:blogId/posts/:postId/comments'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments');

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}}/v3/blogs/:blogId/posts/:postId/comments'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments';
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}}/v3/blogs/:blogId/posts/:postId/comments"]
                                                       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}}/v3/blogs/:blogId/posts/:postId/comments" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments",
  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}}/v3/blogs/:blogId/posts/:postId/comments');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/:blogId/posts/:postId/comments")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments")

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/v3/blogs/:blogId/posts/:postId/comments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/comments");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/:blogId/comments")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/comments"

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

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/comments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/comments"

	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/v3/blogs/:blogId/comments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/blogs/:blogId/comments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/comments"))
    .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}}/v3/blogs/:blogId/comments")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/blogs/:blogId/comments")
  .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}}/v3/blogs/:blogId/comments');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/blogs/:blogId/comments'};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/comments';
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}}/v3/blogs/:blogId/comments',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/comments")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/:blogId/comments');

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}}/v3/blogs/:blogId/comments'};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/comments';
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}}/v3/blogs/:blogId/comments"]
                                                       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}}/v3/blogs/:blogId/comments" in

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

 "{{baseUrl}}/v3/blogs/:blogId/comments",
  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}}/v3/blogs/:blogId/comments');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/comments');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/comments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/comments' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/comments' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/:blogId/comments")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/comments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/comments"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/comments")

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/v3/blogs/:blogId/comments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/comments";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v3/blogs/:blogId/comments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/comments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/comments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam"

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

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

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

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

}

POST /baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam');

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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/spam")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent"

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

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

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

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

}

POST /baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent');

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}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/comments/:commentId/removecontent")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

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

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

	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/v3/blogs/:blogId/pages/:pageId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"))
    .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}}/v3/blogs/:blogId/pages/:pageId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .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}}/v3/blogs/:blogId/pages/:pageId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId';
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}}/v3/blogs/:blogId/pages/:pageId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/pages/:pageId',
  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}}/v3/blogs/:blogId/pages/:pageId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');

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}}/v3/blogs/:blogId/pages/:pageId'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId';
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}}/v3/blogs/:blogId/pages/:pageId"]
                                                       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}}/v3/blogs/:blogId/pages/:pageId" in

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

 "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId",
  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}}/v3/blogs/:blogId/pages/:pageId');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v3/blogs/:blogId/pages/:pageId")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")

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/v3/blogs/:blogId/pages/:pageId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v3/blogs/:blogId/pages/:pageId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/pages/:pageId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

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

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

	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/v3/blogs/:blogId/pages/:pageId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"))
    .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}}/v3/blogs/:blogId/pages/:pageId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .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}}/v3/blogs/:blogId/pages/:pageId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId';
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}}/v3/blogs/:blogId/pages/:pageId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/pages/:pageId',
  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}}/v3/blogs/:blogId/pages/:pageId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');

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}}/v3/blogs/:blogId/pages/:pageId'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId';
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}}/v3/blogs/:blogId/pages/:pageId"]
                                                       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}}/v3/blogs/:blogId/pages/:pageId" in

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

 "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId",
  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}}/v3/blogs/:blogId/pages/:pageId');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/:blogId/pages/:pageId")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")

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/v3/blogs/:blogId/pages/:pageId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v3/blogs/:blogId/pages/:pageId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/pages/:pageId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/pages");

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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v3/blogs/:blogId/pages" {:content-type :json
                                                                   :form-params {:author {:displayName ""
                                                                                          :id ""
                                                                                          :image {:url ""}
                                                                                          :url ""}
                                                                                 :blog {:id ""}
                                                                                 :content ""
                                                                                 :etag ""
                                                                                 :id ""
                                                                                 :kind ""
                                                                                 :published ""
                                                                                 :selfLink ""
                                                                                 :status ""
                                                                                 :title ""
                                                                                 :trashed ""
                                                                                 :updated ""
                                                                                 :url ""}})

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/pages"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/pages"),
    Content = new StringContent("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/pages");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/pages"

	payload := strings.NewReader("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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/v3/blogs/:blogId/pages HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 312

{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/blogs/:blogId/pages")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/pages"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v3/blogs/:blogId/pages")
  .header("content-type", "application/json")
  .body("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  etag: '',
  id: '',
  kind: '',
  published: '',
  selfLink: '',
  status: '',
  title: '',
  trashed: '',
  updated: '',
  url: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v3/blogs/:blogId/pages');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    etag: '',
    id: '',
    kind: '',
    published: '',
    selfLink: '',
    status: '',
    title: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","etag":"","id":"","kind":"","published":"","selfLink":"","status":"","title":"","trashed":"","updated":"","url":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/pages',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "etag": "",\n  "id": "",\n  "kind": "",\n  "published": "",\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages")
  .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/v3/blogs/:blogId/pages',
  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({
  author: {displayName: '', id: '', image: {url: ''}, url: ''},
  blog: {id: ''},
  content: '',
  etag: '',
  id: '',
  kind: '',
  published: '',
  selfLink: '',
  status: '',
  title: '',
  trashed: '',
  updated: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages',
  headers: {'content-type': 'application/json'},
  body: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    etag: '',
    id: '',
    kind: '',
    published: '',
    selfLink: '',
    status: '',
    title: '',
    trashed: '',
    updated: '',
    url: ''
  },
  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}}/v3/blogs/:blogId/pages');

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

req.type('json');
req.send({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  etag: '',
  id: '',
  kind: '',
  published: '',
  selfLink: '',
  status: '',
  title: '',
  trashed: '',
  updated: '',
  url: ''
});

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}}/v3/blogs/:blogId/pages',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    etag: '',
    id: '',
    kind: '',
    published: '',
    selfLink: '',
    status: '',
    title: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","etag":"","id":"","kind":"","published":"","selfLink":"","status":"","title":"","trashed":"","updated":"","url":""}'
};

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 = @{ @"author": @{ @"displayName": @"", @"id": @"", @"image": @{ @"url": @"" }, @"url": @"" },
                              @"blog": @{ @"id": @"" },
                              @"content": @"",
                              @"etag": @"",
                              @"id": @"",
                              @"kind": @"",
                              @"published": @"",
                              @"selfLink": @"",
                              @"status": @"",
                              @"title": @"",
                              @"trashed": @"",
                              @"updated": @"",
                              @"url": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/pages"]
                                                       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}}/v3/blogs/:blogId/pages" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}" in

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

 "{{baseUrl}}/v3/blogs/:blogId/pages",
  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([
    'author' => [
        'displayName' => '',
        'id' => '',
        'image' => [
                'url' => ''
        ],
        'url' => ''
    ],
    'blog' => [
        'id' => ''
    ],
    'content' => '',
    'etag' => '',
    'id' => '',
    'kind' => '',
    'published' => '',
    'selfLink' => '',
    'status' => '',
    'title' => '',
    'trashed' => '',
    'updated' => '',
    'url' => ''
  ]),
  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}}/v3/blogs/:blogId/pages', [
  'body' => '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/pages');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'etag' => '',
  'id' => '',
  'kind' => '',
  'published' => '',
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));

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

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

append(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'etag' => '',
  'id' => '',
  'kind' => '',
  'published' => '',
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/pages');
$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}}/v3/blogs/:blogId/pages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/pages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

import http.client

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

payload = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v3/blogs/:blogId/pages", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/pages"

payload = {
    "author": {
        "displayName": "",
        "id": "",
        "image": { "url": "" },
        "url": ""
    },
    "blog": { "id": "" },
    "content": "",
    "etag": "",
    "id": "",
    "kind": "",
    "published": "",
    "selfLink": "",
    "status": "",
    "title": "",
    "trashed": "",
    "updated": "",
    "url": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/pages"

payload <- "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/pages")

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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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/v3/blogs/:blogId/pages') do |req|
  req.body = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/pages";

    let payload = json!({
        "author": json!({
            "displayName": "",
            "id": "",
            "image": json!({"url": ""}),
            "url": ""
        }),
        "blog": json!({"id": ""}),
        "content": "",
        "etag": "",
        "id": "",
        "kind": "",
        "published": "",
        "selfLink": "",
        "status": "",
        "title": "",
        "trashed": "",
        "updated": "",
        "url": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}' |  \
  http POST {{baseUrl}}/v3/blogs/:blogId/pages \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "etag": "",\n  "id": "",\n  "kind": "",\n  "published": "",\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/pages

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "author": [
    "displayName": "",
    "id": "",
    "image": ["url": ""],
    "url": ""
  ],
  "blog": ["id": ""],
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/pages");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/:blogId/pages")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/pages"

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

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/pages");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/pages"

	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/v3/blogs/:blogId/pages HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/blogs/:blogId/pages")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/pages"))
    .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}}/v3/blogs/:blogId/pages")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/blogs/:blogId/pages")
  .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}}/v3/blogs/:blogId/pages');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/blogs/:blogId/pages'};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages';
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}}/v3/blogs/:blogId/pages',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/:blogId/pages');

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}}/v3/blogs/:blogId/pages'};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages';
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}}/v3/blogs/:blogId/pages"]
                                                       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}}/v3/blogs/:blogId/pages" in

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

 "{{baseUrl}}/v3/blogs/:blogId/pages",
  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}}/v3/blogs/:blogId/pages');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/pages');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/pages');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/pages' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/pages' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/:blogId/pages")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/pages"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/pages"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/pages")

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/v3/blogs/:blogId/pages') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/pages";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v3/blogs/:blogId/pages

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/pages

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/pages")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId");

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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId" {:content-type :json
                                                                            :form-params {:author {:displayName ""
                                                                                                   :id ""
                                                                                                   :image {:url ""}
                                                                                                   :url ""}
                                                                                          :blog {:id ""}
                                                                                          :content ""
                                                                                          :etag ""
                                                                                          :id ""
                                                                                          :kind ""
                                                                                          :published ""
                                                                                          :selfLink ""
                                                                                          :status ""
                                                                                          :title ""
                                                                                          :trashed ""
                                                                                          :updated ""
                                                                                          :url ""}})

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/pages/:pageId"),
    Content = new StringContent("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/pages/:pageId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

	payload := strings.NewReader("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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/v3/blogs/:blogId/pages/:pageId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 312

{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .header("content-type", "application/json")
  .body("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  etag: '',
  id: '',
  kind: '',
  published: '',
  selfLink: '',
  status: '',
  title: '',
  trashed: '',
  updated: '',
  url: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    etag: '',
    id: '',
    kind: '',
    published: '',
    selfLink: '',
    status: '',
    title: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","etag":"","id":"","kind":"","published":"","selfLink":"","status":"","title":"","trashed":"","updated":"","url":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "etag": "",\n  "id": "",\n  "kind": "",\n  "published": "",\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .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/v3/blogs/:blogId/pages/:pageId',
  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({
  author: {displayName: '', id: '', image: {url: ''}, url: ''},
  blog: {id: ''},
  content: '',
  etag: '',
  id: '',
  kind: '',
  published: '',
  selfLink: '',
  status: '',
  title: '',
  trashed: '',
  updated: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId',
  headers: {'content-type': 'application/json'},
  body: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    etag: '',
    id: '',
    kind: '',
    published: '',
    selfLink: '',
    status: '',
    title: '',
    trashed: '',
    updated: '',
    url: ''
  },
  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}}/v3/blogs/:blogId/pages/:pageId');

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

req.type('json');
req.send({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  etag: '',
  id: '',
  kind: '',
  published: '',
  selfLink: '',
  status: '',
  title: '',
  trashed: '',
  updated: '',
  url: ''
});

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}}/v3/blogs/:blogId/pages/:pageId',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    etag: '',
    id: '',
    kind: '',
    published: '',
    selfLink: '',
    status: '',
    title: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","etag":"","id":"","kind":"","published":"","selfLink":"","status":"","title":"","trashed":"","updated":"","url":""}'
};

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 = @{ @"author": @{ @"displayName": @"", @"id": @"", @"image": @{ @"url": @"" }, @"url": @"" },
                              @"blog": @{ @"id": @"" },
                              @"content": @"",
                              @"etag": @"",
                              @"id": @"",
                              @"kind": @"",
                              @"published": @"",
                              @"selfLink": @"",
                              @"status": @"",
                              @"title": @"",
                              @"trashed": @"",
                              @"updated": @"",
                              @"url": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"]
                                                       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}}/v3/blogs/:blogId/pages/:pageId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}" in

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

 "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId",
  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([
    'author' => [
        'displayName' => '',
        'id' => '',
        'image' => [
                'url' => ''
        ],
        'url' => ''
    ],
    'blog' => [
        'id' => ''
    ],
    'content' => '',
    'etag' => '',
    'id' => '',
    'kind' => '',
    'published' => '',
    'selfLink' => '',
    'status' => '',
    'title' => '',
    'trashed' => '',
    'updated' => '',
    'url' => ''
  ]),
  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}}/v3/blogs/:blogId/pages/:pageId', [
  'body' => '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'etag' => '',
  'id' => '',
  'kind' => '',
  'published' => '',
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));

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

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

append(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'etag' => '',
  'id' => '',
  'kind' => '',
  'published' => '',
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');
$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}}/v3/blogs/:blogId/pages/:pageId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

import http.client

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

payload = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/v3/blogs/:blogId/pages/:pageId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

payload = {
    "author": {
        "displayName": "",
        "id": "",
        "image": { "url": "" },
        "url": ""
    },
    "blog": { "id": "" },
    "content": "",
    "etag": "",
    "id": "",
    "kind": "",
    "published": "",
    "selfLink": "",
    "status": "",
    "title": "",
    "trashed": "",
    "updated": "",
    "url": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

payload <- "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/pages/:pageId")

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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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/v3/blogs/:blogId/pages/:pageId') do |req|
  req.body = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/pages/:pageId";

    let payload = json!({
        "author": json!({
            "displayName": "",
            "id": "",
            "image": json!({"url": ""}),
            "url": ""
        }),
        "blog": json!({"id": ""}),
        "content": "",
        "etag": "",
        "id": "",
        "kind": "",
        "published": "",
        "selfLink": "",
        "status": "",
        "title": "",
        "trashed": "",
        "updated": "",
        "url": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}' |  \
  http PATCH {{baseUrl}}/v3/blogs/:blogId/pages/:pageId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "etag": "",\n  "id": "",\n  "kind": "",\n  "published": "",\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/pages/:pageId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "author": [
    "displayName": "",
    "id": "",
    "image": ["url": ""],
    "url": ""
  ],
  "blog": ["id": ""],
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish"

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

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

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

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

}

POST /baseUrl/v3/blogs/:blogId/pages/:pageId/publish HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/pages/:pageId/publish',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish');

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}}/v3/blogs/:blogId/pages/:pageId/publish'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish" in

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

 "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v3/blogs/:blogId/pages/:pageId/publish")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v3/blogs/:blogId/pages/:pageId/publish') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/publish")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert"

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

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

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

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

}

POST /baseUrl/v3/blogs/:blogId/pages/:pageId/revert HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/pages/:pageId/revert',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert');

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}}/v3/blogs/:blogId/pages/:pageId/revert'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert" in

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

 "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v3/blogs/:blogId/pages/:pageId/revert")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v3/blogs/:blogId/pages/:pageId/revert') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId/revert")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId");

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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId" {:content-type :json
                                                                          :form-params {:author {:displayName ""
                                                                                                 :id ""
                                                                                                 :image {:url ""}
                                                                                                 :url ""}
                                                                                        :blog {:id ""}
                                                                                        :content ""
                                                                                        :etag ""
                                                                                        :id ""
                                                                                        :kind ""
                                                                                        :published ""
                                                                                        :selfLink ""
                                                                                        :status ""
                                                                                        :title ""
                                                                                        :trashed ""
                                                                                        :updated ""
                                                                                        :url ""}})

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"),
    Content = new StringContent("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/pages/:pageId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

	payload := strings.NewReader("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")

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

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

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

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

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

}

PUT /baseUrl/v3/blogs/:blogId/pages/:pageId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 312

{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .header("content-type", "application/json")
  .body("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  etag: '',
  id: '',
  kind: '',
  published: '',
  selfLink: '',
  status: '',
  title: '',
  trashed: '',
  updated: '',
  url: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    etag: '',
    id: '',
    kind: '',
    published: '',
    selfLink: '',
    status: '',
    title: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","etag":"","id":"","kind":"","published":"","selfLink":"","status":"","title":"","trashed":"","updated":"","url":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "etag": "",\n  "id": "",\n  "kind": "",\n  "published": "",\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/pages/:pageId',
  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({
  author: {displayName: '', id: '', image: {url: ''}, url: ''},
  blog: {id: ''},
  content: '',
  etag: '',
  id: '',
  kind: '',
  published: '',
  selfLink: '',
  status: '',
  title: '',
  trashed: '',
  updated: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId',
  headers: {'content-type': 'application/json'},
  body: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    etag: '',
    id: '',
    kind: '',
    published: '',
    selfLink: '',
    status: '',
    title: '',
    trashed: '',
    updated: '',
    url: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');

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

req.type('json');
req.send({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  etag: '',
  id: '',
  kind: '',
  published: '',
  selfLink: '',
  status: '',
  title: '',
  trashed: '',
  updated: '',
  url: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    etag: '',
    id: '',
    kind: '',
    published: '',
    selfLink: '',
    status: '',
    title: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","etag":"","id":"","kind":"","published":"","selfLink":"","status":"","title":"","trashed":"","updated":"","url":""}'
};

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 = @{ @"author": @{ @"displayName": @"", @"id": @"", @"image": @{ @"url": @"" }, @"url": @"" },
                              @"blog": @{ @"id": @"" },
                              @"content": @"",
                              @"etag": @"",
                              @"id": @"",
                              @"kind": @"",
                              @"published": @"",
                              @"selfLink": @"",
                              @"status": @"",
                              @"title": @"",
                              @"trashed": @"",
                              @"updated": @"",
                              @"url": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}" in

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

 "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'author' => [
        'displayName' => '',
        'id' => '',
        'image' => [
                'url' => ''
        ],
        'url' => ''
    ],
    'blog' => [
        'id' => ''
    ],
    'content' => '',
    'etag' => '',
    'id' => '',
    'kind' => '',
    'published' => '',
    'selfLink' => '',
    'status' => '',
    'title' => '',
    'trashed' => '',
    'updated' => '',
    'url' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId', [
  'body' => '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'etag' => '',
  'id' => '',
  'kind' => '',
  'published' => '',
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));

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

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

append(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'etag' => '',
  'id' => '',
  'kind' => '',
  'published' => '',
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/pages/:pageId');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/pages/:pageId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

import http.client

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

payload = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/v3/blogs/:blogId/pages/:pageId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

payload = {
    "author": {
        "displayName": "",
        "id": "",
        "image": { "url": "" },
        "url": ""
    },
    "blog": { "id": "" },
    "content": "",
    "etag": "",
    "id": "",
    "kind": "",
    "published": "",
    "selfLink": "",
    "status": "",
    "title": "",
    "trashed": "",
    "updated": "",
    "url": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId"

payload <- "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/v3/blogs/:blogId/pages/:pageId') do |req|
  req.body = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"published\": \"\",\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/pages/:pageId";

    let payload = json!({
        "author": json!({
            "displayName": "",
            "id": "",
            "image": json!({"url": ""}),
            "url": ""
        }),
        "blog": json!({"id": ""}),
        "content": "",
        "etag": "",
        "id": "",
        "kind": "",
        "published": "",
        "selfLink": "",
        "status": "",
        "title": "",
        "trashed": "",
        "updated": "",
        "url": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
}' |  \
  http PUT {{baseUrl}}/v3/blogs/:blogId/pages/:pageId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "etag": "",\n  "id": "",\n  "kind": "",\n  "published": "",\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/pages/:pageId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "author": [
    "displayName": "",
    "id": "",
    "image": ["url": ""],
    "url": ""
  ],
  "blog": ["id": ""],
  "content": "",
  "etag": "",
  "id": "",
  "kind": "",
  "published": "",
  "selfLink": "",
  "status": "",
  "title": "",
  "trashed": "",
  "updated": "",
  "url": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/pages/:pageId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/pageviews");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/:blogId/pageviews")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/pageviews"

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

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/pageviews");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/pageviews"

	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/v3/blogs/:blogId/pageviews HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/blogs/:blogId/pageviews")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/pageviews"))
    .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}}/v3/blogs/:blogId/pageviews")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/blogs/:blogId/pageviews")
  .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}}/v3/blogs/:blogId/pageviews');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/blogs/:blogId/pageviews'};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pageviews';
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}}/v3/blogs/:blogId/pageviews',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/pageviews")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/:blogId/pageviews');

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}}/v3/blogs/:blogId/pageviews'};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/pageviews';
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}}/v3/blogs/:blogId/pageviews"]
                                                       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}}/v3/blogs/:blogId/pageviews" in

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

 "{{baseUrl}}/v3/blogs/:blogId/pageviews",
  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}}/v3/blogs/:blogId/pageviews');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/pageviews');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/pageviews');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/pageviews' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/pageviews' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/:blogId/pageviews")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/pageviews"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/pageviews"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/pageviews")

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/v3/blogs/:blogId/pageviews') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/pageviews";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v3/blogs/:blogId/pageviews

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/pageviews

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/pageviews")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v3/blogs/:blogId/posts/:postId")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

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

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/:postId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

	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/v3/blogs/:blogId/posts/:postId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId"))
    .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}}/v3/blogs/:blogId/posts/:postId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .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}}/v3/blogs/:blogId/posts/:postId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId';
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}}/v3/blogs/:blogId/posts/:postId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/:postId',
  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}}/v3/blogs/:blogId/posts/:postId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId');

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}}/v3/blogs/:blogId/posts/:postId'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId';
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}}/v3/blogs/:blogId/posts/:postId"]
                                                       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}}/v3/blogs/:blogId/posts/:postId" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId",
  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}}/v3/blogs/:blogId/posts/:postId');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v3/blogs/:blogId/posts/:postId")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")

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/v3/blogs/:blogId/posts/:postId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/v3/blogs/:blogId/posts/:postId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/:blogId/posts/:postId")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

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

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/:postId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

	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/v3/blogs/:blogId/posts/:postId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId"))
    .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}}/v3/blogs/:blogId/posts/:postId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .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}}/v3/blogs/:blogId/posts/:postId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId';
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}}/v3/blogs/:blogId/posts/:postId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/:postId',
  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}}/v3/blogs/:blogId/posts/:postId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId');

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}}/v3/blogs/:blogId/posts/:postId'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId';
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}}/v3/blogs/:blogId/posts/:postId"]
                                                       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}}/v3/blogs/:blogId/posts/:postId" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId",
  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}}/v3/blogs/:blogId/posts/:postId');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/:blogId/posts/:postId")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")

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/v3/blogs/:blogId/posts/:postId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v3/blogs/:blogId/posts/:postId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/:blogId/posts/bypath" {:query-params {:path ""}})

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path="

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}}/v3/blogs/:blogId/posts/bypath?path="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path="

	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/v3/blogs/:blogId/posts/bypath?path= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path="))
    .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}}/v3/blogs/:blogId/posts/bypath?path=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=")
  .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}}/v3/blogs/:blogId/posts/bypath?path=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/bypath',
  params: {path: ''}
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=';
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}}/v3/blogs/:blogId/posts/bypath?path=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/bypath?path=',
  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}}/v3/blogs/:blogId/posts/bypath',
  qs: {path: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/:blogId/posts/bypath');

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

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}}/v3/blogs/:blogId/posts/bypath',
  params: {path: ''}
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=';
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}}/v3/blogs/:blogId/posts/bypath?path="]
                                                       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}}/v3/blogs/:blogId/posts/bypath?path=" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=",
  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}}/v3/blogs/:blogId/posts/bypath?path=');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/bypath');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/bypath');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'path' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/:blogId/posts/bypath?path=")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/bypath"

querystring = {"path":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/bypath"

queryString <- list(path = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=")

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/v3/blogs/:blogId/posts/bypath') do |req|
  req.params['path'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/bypath";

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

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/bypath?path=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts");

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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v3/blogs/:blogId/posts" {:content-type :json
                                                                   :form-params {:author {:displayName ""
                                                                                          :id ""
                                                                                          :image {:url ""}
                                                                                          :url ""}
                                                                                 :blog {:id ""}
                                                                                 :content ""
                                                                                 :customMetaData ""
                                                                                 :etag ""
                                                                                 :id ""
                                                                                 :images [{:url ""}]
                                                                                 :kind ""
                                                                                 :labels []
                                                                                 :location {:lat ""
                                                                                            :lng ""
                                                                                            :name ""
                                                                                            :span ""}
                                                                                 :published ""
                                                                                 :readerComments ""
                                                                                 :replies {:items [{:author {:displayName ""
                                                                                                             :id ""
                                                                                                             :image {:url ""}
                                                                                                             :url ""}
                                                                                                    :blog {:id ""}
                                                                                                    :content ""
                                                                                                    :id ""
                                                                                                    :inReplyTo {:id ""}
                                                                                                    :kind ""
                                                                                                    :post {:id ""}
                                                                                                    :published ""
                                                                                                    :selfLink ""
                                                                                                    :status ""
                                                                                                    :updated ""}]
                                                                                           :selfLink ""
                                                                                           :totalItems ""}
                                                                                 :selfLink ""
                                                                                 :status ""
                                                                                 :title ""
                                                                                 :titleLink ""
                                                                                 :trashed ""
                                                                                 :updated ""
                                                                                 :url ""}})

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/posts"),
    Content = new StringContent("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/posts");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts"

	payload := strings.NewReader("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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/v3/blogs/:blogId/posts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1082

{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/blogs/:blogId/posts")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v3/blogs/:blogId/posts")
  .header("content-type", "application/json")
  .body("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  customMetaData: '',
  etag: '',
  id: '',
  images: [
    {
      url: ''
    }
  ],
  kind: '',
  labels: [],
  location: {
    lat: '',
    lng: '',
    name: '',
    span: ''
  },
  published: '',
  readerComments: '',
  replies: {
    items: [
      {
        author: {
          displayName: '',
          id: '',
          image: {
            url: ''
          },
          url: ''
        },
        blog: {
          id: ''
        },
        content: '',
        id: '',
        inReplyTo: {
          id: ''
        },
        kind: '',
        post: {
          id: ''
        },
        published: '',
        selfLink: '',
        status: '',
        updated: ''
      }
    ],
    selfLink: '',
    totalItems: ''
  },
  selfLink: '',
  status: '',
  title: '',
  titleLink: '',
  trashed: '',
  updated: '',
  url: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v3/blogs/:blogId/posts');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    customMetaData: '',
    etag: '',
    id: '',
    images: [{url: ''}],
    kind: '',
    labels: [],
    location: {lat: '', lng: '', name: '', span: ''},
    published: '',
    readerComments: '',
    replies: {
      items: [
        {
          author: {displayName: '', id: '', image: {url: ''}, url: ''},
          blog: {id: ''},
          content: '',
          id: '',
          inReplyTo: {id: ''},
          kind: '',
          post: {id: ''},
          published: '',
          selfLink: '',
          status: '',
          updated: ''
        }
      ],
      selfLink: '',
      totalItems: ''
    },
    selfLink: '',
    status: '',
    title: '',
    titleLink: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","customMetaData":"","etag":"","id":"","images":[{"url":""}],"kind":"","labels":[],"location":{"lat":"","lng":"","name":"","span":""},"published":"","readerComments":"","replies":{"items":[{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","id":"","inReplyTo":{"id":""},"kind":"","post":{"id":""},"published":"","selfLink":"","status":"","updated":""}],"selfLink":"","totalItems":""},"selfLink":"","status":"","title":"","titleLink":"","trashed":"","updated":"","url":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/posts',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "customMetaData": "",\n  "etag": "",\n  "id": "",\n  "images": [\n    {\n      "url": ""\n    }\n  ],\n  "kind": "",\n  "labels": [],\n  "location": {\n    "lat": "",\n    "lng": "",\n    "name": "",\n    "span": ""\n  },\n  "published": "",\n  "readerComments": "",\n  "replies": {\n    "items": [\n      {\n        "author": {\n          "displayName": "",\n          "id": "",\n          "image": {\n            "url": ""\n          },\n          "url": ""\n        },\n        "blog": {\n          "id": ""\n        },\n        "content": "",\n        "id": "",\n        "inReplyTo": {\n          "id": ""\n        },\n        "kind": "",\n        "post": {\n          "id": ""\n        },\n        "published": "",\n        "selfLink": "",\n        "status": "",\n        "updated": ""\n      }\n    ],\n    "selfLink": "",\n    "totalItems": ""\n  },\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "titleLink": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts")
  .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/v3/blogs/:blogId/posts',
  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({
  author: {displayName: '', id: '', image: {url: ''}, url: ''},
  blog: {id: ''},
  content: '',
  customMetaData: '',
  etag: '',
  id: '',
  images: [{url: ''}],
  kind: '',
  labels: [],
  location: {lat: '', lng: '', name: '', span: ''},
  published: '',
  readerComments: '',
  replies: {
    items: [
      {
        author: {displayName: '', id: '', image: {url: ''}, url: ''},
        blog: {id: ''},
        content: '',
        id: '',
        inReplyTo: {id: ''},
        kind: '',
        post: {id: ''},
        published: '',
        selfLink: '',
        status: '',
        updated: ''
      }
    ],
    selfLink: '',
    totalItems: ''
  },
  selfLink: '',
  status: '',
  title: '',
  titleLink: '',
  trashed: '',
  updated: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts',
  headers: {'content-type': 'application/json'},
  body: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    customMetaData: '',
    etag: '',
    id: '',
    images: [{url: ''}],
    kind: '',
    labels: [],
    location: {lat: '', lng: '', name: '', span: ''},
    published: '',
    readerComments: '',
    replies: {
      items: [
        {
          author: {displayName: '', id: '', image: {url: ''}, url: ''},
          blog: {id: ''},
          content: '',
          id: '',
          inReplyTo: {id: ''},
          kind: '',
          post: {id: ''},
          published: '',
          selfLink: '',
          status: '',
          updated: ''
        }
      ],
      selfLink: '',
      totalItems: ''
    },
    selfLink: '',
    status: '',
    title: '',
    titleLink: '',
    trashed: '',
    updated: '',
    url: ''
  },
  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}}/v3/blogs/:blogId/posts');

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

req.type('json');
req.send({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  customMetaData: '',
  etag: '',
  id: '',
  images: [
    {
      url: ''
    }
  ],
  kind: '',
  labels: [],
  location: {
    lat: '',
    lng: '',
    name: '',
    span: ''
  },
  published: '',
  readerComments: '',
  replies: {
    items: [
      {
        author: {
          displayName: '',
          id: '',
          image: {
            url: ''
          },
          url: ''
        },
        blog: {
          id: ''
        },
        content: '',
        id: '',
        inReplyTo: {
          id: ''
        },
        kind: '',
        post: {
          id: ''
        },
        published: '',
        selfLink: '',
        status: '',
        updated: ''
      }
    ],
    selfLink: '',
    totalItems: ''
  },
  selfLink: '',
  status: '',
  title: '',
  titleLink: '',
  trashed: '',
  updated: '',
  url: ''
});

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}}/v3/blogs/:blogId/posts',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    customMetaData: '',
    etag: '',
    id: '',
    images: [{url: ''}],
    kind: '',
    labels: [],
    location: {lat: '', lng: '', name: '', span: ''},
    published: '',
    readerComments: '',
    replies: {
      items: [
        {
          author: {displayName: '', id: '', image: {url: ''}, url: ''},
          blog: {id: ''},
          content: '',
          id: '',
          inReplyTo: {id: ''},
          kind: '',
          post: {id: ''},
          published: '',
          selfLink: '',
          status: '',
          updated: ''
        }
      ],
      selfLink: '',
      totalItems: ''
    },
    selfLink: '',
    status: '',
    title: '',
    titleLink: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","customMetaData":"","etag":"","id":"","images":[{"url":""}],"kind":"","labels":[],"location":{"lat":"","lng":"","name":"","span":""},"published":"","readerComments":"","replies":{"items":[{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","id":"","inReplyTo":{"id":""},"kind":"","post":{"id":""},"published":"","selfLink":"","status":"","updated":""}],"selfLink":"","totalItems":""},"selfLink":"","status":"","title":"","titleLink":"","trashed":"","updated":"","url":""}'
};

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 = @{ @"author": @{ @"displayName": @"", @"id": @"", @"image": @{ @"url": @"" }, @"url": @"" },
                              @"blog": @{ @"id": @"" },
                              @"content": @"",
                              @"customMetaData": @"",
                              @"etag": @"",
                              @"id": @"",
                              @"images": @[ @{ @"url": @"" } ],
                              @"kind": @"",
                              @"labels": @[  ],
                              @"location": @{ @"lat": @"", @"lng": @"", @"name": @"", @"span": @"" },
                              @"published": @"",
                              @"readerComments": @"",
                              @"replies": @{ @"items": @[ @{ @"author": @{ @"displayName": @"", @"id": @"", @"image": @{ @"url": @"" }, @"url": @"" }, @"blog": @{ @"id": @"" }, @"content": @"", @"id": @"", @"inReplyTo": @{ @"id": @"" }, @"kind": @"", @"post": @{ @"id": @"" }, @"published": @"", @"selfLink": @"", @"status": @"", @"updated": @"" } ], @"selfLink": @"", @"totalItems": @"" },
                              @"selfLink": @"",
                              @"status": @"",
                              @"title": @"",
                              @"titleLink": @"",
                              @"trashed": @"",
                              @"updated": @"",
                              @"url": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/posts"]
                                                       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}}/v3/blogs/:blogId/posts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts",
  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([
    'author' => [
        'displayName' => '',
        'id' => '',
        'image' => [
                'url' => ''
        ],
        'url' => ''
    ],
    'blog' => [
        'id' => ''
    ],
    'content' => '',
    'customMetaData' => '',
    'etag' => '',
    'id' => '',
    'images' => [
        [
                'url' => ''
        ]
    ],
    'kind' => '',
    'labels' => [
        
    ],
    'location' => [
        'lat' => '',
        'lng' => '',
        'name' => '',
        'span' => ''
    ],
    'published' => '',
    'readerComments' => '',
    'replies' => [
        'items' => [
                [
                                'author' => [
                                                                'displayName' => '',
                                                                'id' => '',
                                                                'image' => [
                                                                                                                                'url' => ''
                                                                ],
                                                                'url' => ''
                                ],
                                'blog' => [
                                                                'id' => ''
                                ],
                                'content' => '',
                                'id' => '',
                                'inReplyTo' => [
                                                                'id' => ''
                                ],
                                'kind' => '',
                                'post' => [
                                                                'id' => ''
                                ],
                                'published' => '',
                                'selfLink' => '',
                                'status' => '',
                                'updated' => ''
                ]
        ],
        'selfLink' => '',
        'totalItems' => ''
    ],
    'selfLink' => '',
    'status' => '',
    'title' => '',
    'titleLink' => '',
    'trashed' => '',
    'updated' => '',
    'url' => ''
  ]),
  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}}/v3/blogs/:blogId/posts', [
  'body' => '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'customMetaData' => '',
  'etag' => '',
  'id' => '',
  'images' => [
    [
        'url' => ''
    ]
  ],
  'kind' => '',
  'labels' => [
    
  ],
  'location' => [
    'lat' => '',
    'lng' => '',
    'name' => '',
    'span' => ''
  ],
  'published' => '',
  'readerComments' => '',
  'replies' => [
    'items' => [
        [
                'author' => [
                                'displayName' => '',
                                'id' => '',
                                'image' => [
                                                                'url' => ''
                                ],
                                'url' => ''
                ],
                'blog' => [
                                'id' => ''
                ],
                'content' => '',
                'id' => '',
                'inReplyTo' => [
                                'id' => ''
                ],
                'kind' => '',
                'post' => [
                                'id' => ''
                ],
                'published' => '',
                'selfLink' => '',
                'status' => '',
                'updated' => ''
        ]
    ],
    'selfLink' => '',
    'totalItems' => ''
  ],
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'titleLink' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));

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

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

append(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'customMetaData' => '',
  'etag' => '',
  'id' => '',
  'images' => [
    [
        'url' => ''
    ]
  ],
  'kind' => '',
  'labels' => [
    
  ],
  'location' => [
    'lat' => '',
    'lng' => '',
    'name' => '',
    'span' => ''
  ],
  'published' => '',
  'readerComments' => '',
  'replies' => [
    'items' => [
        [
                'author' => [
                                'displayName' => '',
                                'id' => '',
                                'image' => [
                                                                'url' => ''
                                ],
                                'url' => ''
                ],
                'blog' => [
                                'id' => ''
                ],
                'content' => '',
                'id' => '',
                'inReplyTo' => [
                                'id' => ''
                ],
                'kind' => '',
                'post' => [
                                'id' => ''
                ],
                'published' => '',
                'selfLink' => '',
                'status' => '',
                'updated' => ''
        ]
    ],
    'selfLink' => '',
    'totalItems' => ''
  ],
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'titleLink' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts');
$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}}/v3/blogs/:blogId/posts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

import http.client

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

payload = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v3/blogs/:blogId/posts", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts"

payload = {
    "author": {
        "displayName": "",
        "id": "",
        "image": { "url": "" },
        "url": ""
    },
    "blog": { "id": "" },
    "content": "",
    "customMetaData": "",
    "etag": "",
    "id": "",
    "images": [{ "url": "" }],
    "kind": "",
    "labels": [],
    "location": {
        "lat": "",
        "lng": "",
        "name": "",
        "span": ""
    },
    "published": "",
    "readerComments": "",
    "replies": {
        "items": [
            {
                "author": {
                    "displayName": "",
                    "id": "",
                    "image": { "url": "" },
                    "url": ""
                },
                "blog": { "id": "" },
                "content": "",
                "id": "",
                "inReplyTo": { "id": "" },
                "kind": "",
                "post": { "id": "" },
                "published": "",
                "selfLink": "",
                "status": "",
                "updated": ""
            }
        ],
        "selfLink": "",
        "totalItems": ""
    },
    "selfLink": "",
    "status": "",
    "title": "",
    "titleLink": "",
    "trashed": "",
    "updated": "",
    "url": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts"

payload <- "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/posts")

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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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/v3/blogs/:blogId/posts') do |req|
  req.body = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts";

    let payload = json!({
        "author": json!({
            "displayName": "",
            "id": "",
            "image": json!({"url": ""}),
            "url": ""
        }),
        "blog": json!({"id": ""}),
        "content": "",
        "customMetaData": "",
        "etag": "",
        "id": "",
        "images": (json!({"url": ""})),
        "kind": "",
        "labels": (),
        "location": json!({
            "lat": "",
            "lng": "",
            "name": "",
            "span": ""
        }),
        "published": "",
        "readerComments": "",
        "replies": json!({
            "items": (
                json!({
                    "author": json!({
                        "displayName": "",
                        "id": "",
                        "image": json!({"url": ""}),
                        "url": ""
                    }),
                    "blog": json!({"id": ""}),
                    "content": "",
                    "id": "",
                    "inReplyTo": json!({"id": ""}),
                    "kind": "",
                    "post": json!({"id": ""}),
                    "published": "",
                    "selfLink": "",
                    "status": "",
                    "updated": ""
                })
            ),
            "selfLink": "",
            "totalItems": ""
        }),
        "selfLink": "",
        "status": "",
        "title": "",
        "titleLink": "",
        "trashed": "",
        "updated": "",
        "url": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}' |  \
  http POST {{baseUrl}}/v3/blogs/:blogId/posts \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "customMetaData": "",\n  "etag": "",\n  "id": "",\n  "images": [\n    {\n      "url": ""\n    }\n  ],\n  "kind": "",\n  "labels": [],\n  "location": {\n    "lat": "",\n    "lng": "",\n    "name": "",\n    "span": ""\n  },\n  "published": "",\n  "readerComments": "",\n  "replies": {\n    "items": [\n      {\n        "author": {\n          "displayName": "",\n          "id": "",\n          "image": {\n            "url": ""\n          },\n          "url": ""\n        },\n        "blog": {\n          "id": ""\n        },\n        "content": "",\n        "id": "",\n        "inReplyTo": {\n          "id": ""\n        },\n        "kind": "",\n        "post": {\n          "id": ""\n        },\n        "published": "",\n        "selfLink": "",\n        "status": "",\n        "updated": ""\n      }\n    ],\n    "selfLink": "",\n    "totalItems": ""\n  },\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "titleLink": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "author": [
    "displayName": "",
    "id": "",
    "image": ["url": ""],
    "url": ""
  ],
  "blog": ["id": ""],
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [["url": ""]],
  "kind": "",
  "labels": [],
  "location": [
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  ],
  "published": "",
  "readerComments": "",
  "replies": [
    "items": [
      [
        "author": [
          "displayName": "",
          "id": "",
          "image": ["url": ""],
          "url": ""
        ],
        "blog": ["id": ""],
        "content": "",
        "id": "",
        "inReplyTo": ["id": ""],
        "kind": "",
        "post": ["id": ""],
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      ]
    ],
    "selfLink": "",
    "totalItems": ""
  ],
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/:blogId/posts")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts"

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

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts"

	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/v3/blogs/:blogId/posts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/blogs/:blogId/posts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts"))
    .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}}/v3/blogs/:blogId/posts")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/blogs/:blogId/posts")
  .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}}/v3/blogs/:blogId/posts');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/blogs/:blogId/posts'};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts';
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}}/v3/blogs/:blogId/posts',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/:blogId/posts');

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}}/v3/blogs/:blogId/posts'};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts';
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}}/v3/blogs/:blogId/posts"]
                                                       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}}/v3/blogs/:blogId/posts" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts",
  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}}/v3/blogs/:blogId/posts');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/:blogId/posts")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts")

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/v3/blogs/:blogId/posts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v3/blogs/:blogId/posts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId");

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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v3/blogs/:blogId/posts/:postId" {:content-type :json
                                                                            :form-params {:author {:displayName ""
                                                                                                   :id ""
                                                                                                   :image {:url ""}
                                                                                                   :url ""}
                                                                                          :blog {:id ""}
                                                                                          :content ""
                                                                                          :customMetaData ""
                                                                                          :etag ""
                                                                                          :id ""
                                                                                          :images [{:url ""}]
                                                                                          :kind ""
                                                                                          :labels []
                                                                                          :location {:lat ""
                                                                                                     :lng ""
                                                                                                     :name ""
                                                                                                     :span ""}
                                                                                          :published ""
                                                                                          :readerComments ""
                                                                                          :replies {:items [{:author {:displayName ""
                                                                                                                      :id ""
                                                                                                                      :image {:url ""}
                                                                                                                      :url ""}
                                                                                                             :blog {:id ""}
                                                                                                             :content ""
                                                                                                             :id ""
                                                                                                             :inReplyTo {:id ""}
                                                                                                             :kind ""
                                                                                                             :post {:id ""}
                                                                                                             :published ""
                                                                                                             :selfLink ""
                                                                                                             :status ""
                                                                                                             :updated ""}]
                                                                                                    :selfLink ""
                                                                                                    :totalItems ""}
                                                                                          :selfLink ""
                                                                                          :status ""
                                                                                          :title ""
                                                                                          :titleLink ""
                                                                                          :trashed ""
                                                                                          :updated ""
                                                                                          :url ""}})

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/posts/:postId"),
    Content = new StringContent("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/posts/:postId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

	payload := strings.NewReader("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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/v3/blogs/:blogId/posts/:postId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1082

{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .header("content-type", "application/json")
  .body("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  customMetaData: '',
  etag: '',
  id: '',
  images: [
    {
      url: ''
    }
  ],
  kind: '',
  labels: [],
  location: {
    lat: '',
    lng: '',
    name: '',
    span: ''
  },
  published: '',
  readerComments: '',
  replies: {
    items: [
      {
        author: {
          displayName: '',
          id: '',
          image: {
            url: ''
          },
          url: ''
        },
        blog: {
          id: ''
        },
        content: '',
        id: '',
        inReplyTo: {
          id: ''
        },
        kind: '',
        post: {
          id: ''
        },
        published: '',
        selfLink: '',
        status: '',
        updated: ''
      }
    ],
    selfLink: '',
    totalItems: ''
  },
  selfLink: '',
  status: '',
  title: '',
  titleLink: '',
  trashed: '',
  updated: '',
  url: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    customMetaData: '',
    etag: '',
    id: '',
    images: [{url: ''}],
    kind: '',
    labels: [],
    location: {lat: '', lng: '', name: '', span: ''},
    published: '',
    readerComments: '',
    replies: {
      items: [
        {
          author: {displayName: '', id: '', image: {url: ''}, url: ''},
          blog: {id: ''},
          content: '',
          id: '',
          inReplyTo: {id: ''},
          kind: '',
          post: {id: ''},
          published: '',
          selfLink: '',
          status: '',
          updated: ''
        }
      ],
      selfLink: '',
      totalItems: ''
    },
    selfLink: '',
    status: '',
    title: '',
    titleLink: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","customMetaData":"","etag":"","id":"","images":[{"url":""}],"kind":"","labels":[],"location":{"lat":"","lng":"","name":"","span":""},"published":"","readerComments":"","replies":{"items":[{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","id":"","inReplyTo":{"id":""},"kind":"","post":{"id":""},"published":"","selfLink":"","status":"","updated":""}],"selfLink":"","totalItems":""},"selfLink":"","status":"","title":"","titleLink":"","trashed":"","updated":"","url":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "customMetaData": "",\n  "etag": "",\n  "id": "",\n  "images": [\n    {\n      "url": ""\n    }\n  ],\n  "kind": "",\n  "labels": [],\n  "location": {\n    "lat": "",\n    "lng": "",\n    "name": "",\n    "span": ""\n  },\n  "published": "",\n  "readerComments": "",\n  "replies": {\n    "items": [\n      {\n        "author": {\n          "displayName": "",\n          "id": "",\n          "image": {\n            "url": ""\n          },\n          "url": ""\n        },\n        "blog": {\n          "id": ""\n        },\n        "content": "",\n        "id": "",\n        "inReplyTo": {\n          "id": ""\n        },\n        "kind": "",\n        "post": {\n          "id": ""\n        },\n        "published": "",\n        "selfLink": "",\n        "status": "",\n        "updated": ""\n      }\n    ],\n    "selfLink": "",\n    "totalItems": ""\n  },\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "titleLink": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .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/v3/blogs/:blogId/posts/:postId',
  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({
  author: {displayName: '', id: '', image: {url: ''}, url: ''},
  blog: {id: ''},
  content: '',
  customMetaData: '',
  etag: '',
  id: '',
  images: [{url: ''}],
  kind: '',
  labels: [],
  location: {lat: '', lng: '', name: '', span: ''},
  published: '',
  readerComments: '',
  replies: {
    items: [
      {
        author: {displayName: '', id: '', image: {url: ''}, url: ''},
        blog: {id: ''},
        content: '',
        id: '',
        inReplyTo: {id: ''},
        kind: '',
        post: {id: ''},
        published: '',
        selfLink: '',
        status: '',
        updated: ''
      }
    ],
    selfLink: '',
    totalItems: ''
  },
  selfLink: '',
  status: '',
  title: '',
  titleLink: '',
  trashed: '',
  updated: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId',
  headers: {'content-type': 'application/json'},
  body: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    customMetaData: '',
    etag: '',
    id: '',
    images: [{url: ''}],
    kind: '',
    labels: [],
    location: {lat: '', lng: '', name: '', span: ''},
    published: '',
    readerComments: '',
    replies: {
      items: [
        {
          author: {displayName: '', id: '', image: {url: ''}, url: ''},
          blog: {id: ''},
          content: '',
          id: '',
          inReplyTo: {id: ''},
          kind: '',
          post: {id: ''},
          published: '',
          selfLink: '',
          status: '',
          updated: ''
        }
      ],
      selfLink: '',
      totalItems: ''
    },
    selfLink: '',
    status: '',
    title: '',
    titleLink: '',
    trashed: '',
    updated: '',
    url: ''
  },
  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}}/v3/blogs/:blogId/posts/:postId');

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

req.type('json');
req.send({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  customMetaData: '',
  etag: '',
  id: '',
  images: [
    {
      url: ''
    }
  ],
  kind: '',
  labels: [],
  location: {
    lat: '',
    lng: '',
    name: '',
    span: ''
  },
  published: '',
  readerComments: '',
  replies: {
    items: [
      {
        author: {
          displayName: '',
          id: '',
          image: {
            url: ''
          },
          url: ''
        },
        blog: {
          id: ''
        },
        content: '',
        id: '',
        inReplyTo: {
          id: ''
        },
        kind: '',
        post: {
          id: ''
        },
        published: '',
        selfLink: '',
        status: '',
        updated: ''
      }
    ],
    selfLink: '',
    totalItems: ''
  },
  selfLink: '',
  status: '',
  title: '',
  titleLink: '',
  trashed: '',
  updated: '',
  url: ''
});

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}}/v3/blogs/:blogId/posts/:postId',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    customMetaData: '',
    etag: '',
    id: '',
    images: [{url: ''}],
    kind: '',
    labels: [],
    location: {lat: '', lng: '', name: '', span: ''},
    published: '',
    readerComments: '',
    replies: {
      items: [
        {
          author: {displayName: '', id: '', image: {url: ''}, url: ''},
          blog: {id: ''},
          content: '',
          id: '',
          inReplyTo: {id: ''},
          kind: '',
          post: {id: ''},
          published: '',
          selfLink: '',
          status: '',
          updated: ''
        }
      ],
      selfLink: '',
      totalItems: ''
    },
    selfLink: '',
    status: '',
    title: '',
    titleLink: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","customMetaData":"","etag":"","id":"","images":[{"url":""}],"kind":"","labels":[],"location":{"lat":"","lng":"","name":"","span":""},"published":"","readerComments":"","replies":{"items":[{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","id":"","inReplyTo":{"id":""},"kind":"","post":{"id":""},"published":"","selfLink":"","status":"","updated":""}],"selfLink":"","totalItems":""},"selfLink":"","status":"","title":"","titleLink":"","trashed":"","updated":"","url":""}'
};

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 = @{ @"author": @{ @"displayName": @"", @"id": @"", @"image": @{ @"url": @"" }, @"url": @"" },
                              @"blog": @{ @"id": @"" },
                              @"content": @"",
                              @"customMetaData": @"",
                              @"etag": @"",
                              @"id": @"",
                              @"images": @[ @{ @"url": @"" } ],
                              @"kind": @"",
                              @"labels": @[  ],
                              @"location": @{ @"lat": @"", @"lng": @"", @"name": @"", @"span": @"" },
                              @"published": @"",
                              @"readerComments": @"",
                              @"replies": @{ @"items": @[ @{ @"author": @{ @"displayName": @"", @"id": @"", @"image": @{ @"url": @"" }, @"url": @"" }, @"blog": @{ @"id": @"" }, @"content": @"", @"id": @"", @"inReplyTo": @{ @"id": @"" }, @"kind": @"", @"post": @{ @"id": @"" }, @"published": @"", @"selfLink": @"", @"status": @"", @"updated": @"" } ], @"selfLink": @"", @"totalItems": @"" },
                              @"selfLink": @"",
                              @"status": @"",
                              @"title": @"",
                              @"titleLink": @"",
                              @"trashed": @"",
                              @"updated": @"",
                              @"url": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/posts/:postId"]
                                                       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}}/v3/blogs/:blogId/posts/:postId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId",
  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([
    'author' => [
        'displayName' => '',
        'id' => '',
        'image' => [
                'url' => ''
        ],
        'url' => ''
    ],
    'blog' => [
        'id' => ''
    ],
    'content' => '',
    'customMetaData' => '',
    'etag' => '',
    'id' => '',
    'images' => [
        [
                'url' => ''
        ]
    ],
    'kind' => '',
    'labels' => [
        
    ],
    'location' => [
        'lat' => '',
        'lng' => '',
        'name' => '',
        'span' => ''
    ],
    'published' => '',
    'readerComments' => '',
    'replies' => [
        'items' => [
                [
                                'author' => [
                                                                'displayName' => '',
                                                                'id' => '',
                                                                'image' => [
                                                                                                                                'url' => ''
                                                                ],
                                                                'url' => ''
                                ],
                                'blog' => [
                                                                'id' => ''
                                ],
                                'content' => '',
                                'id' => '',
                                'inReplyTo' => [
                                                                'id' => ''
                                ],
                                'kind' => '',
                                'post' => [
                                                                'id' => ''
                                ],
                                'published' => '',
                                'selfLink' => '',
                                'status' => '',
                                'updated' => ''
                ]
        ],
        'selfLink' => '',
        'totalItems' => ''
    ],
    'selfLink' => '',
    'status' => '',
    'title' => '',
    'titleLink' => '',
    'trashed' => '',
    'updated' => '',
    'url' => ''
  ]),
  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}}/v3/blogs/:blogId/posts/:postId', [
  'body' => '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'customMetaData' => '',
  'etag' => '',
  'id' => '',
  'images' => [
    [
        'url' => ''
    ]
  ],
  'kind' => '',
  'labels' => [
    
  ],
  'location' => [
    'lat' => '',
    'lng' => '',
    'name' => '',
    'span' => ''
  ],
  'published' => '',
  'readerComments' => '',
  'replies' => [
    'items' => [
        [
                'author' => [
                                'displayName' => '',
                                'id' => '',
                                'image' => [
                                                                'url' => ''
                                ],
                                'url' => ''
                ],
                'blog' => [
                                'id' => ''
                ],
                'content' => '',
                'id' => '',
                'inReplyTo' => [
                                'id' => ''
                ],
                'kind' => '',
                'post' => [
                                'id' => ''
                ],
                'published' => '',
                'selfLink' => '',
                'status' => '',
                'updated' => ''
        ]
    ],
    'selfLink' => '',
    'totalItems' => ''
  ],
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'titleLink' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));

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

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

append(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'customMetaData' => '',
  'etag' => '',
  'id' => '',
  'images' => [
    [
        'url' => ''
    ]
  ],
  'kind' => '',
  'labels' => [
    
  ],
  'location' => [
    'lat' => '',
    'lng' => '',
    'name' => '',
    'span' => ''
  ],
  'published' => '',
  'readerComments' => '',
  'replies' => [
    'items' => [
        [
                'author' => [
                                'displayName' => '',
                                'id' => '',
                                'image' => [
                                                                'url' => ''
                                ],
                                'url' => ''
                ],
                'blog' => [
                                'id' => ''
                ],
                'content' => '',
                'id' => '',
                'inReplyTo' => [
                                'id' => ''
                ],
                'kind' => '',
                'post' => [
                                'id' => ''
                ],
                'published' => '',
                'selfLink' => '',
                'status' => '',
                'updated' => ''
        ]
    ],
    'selfLink' => '',
    'totalItems' => ''
  ],
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'titleLink' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId');
$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}}/v3/blogs/:blogId/posts/:postId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

import http.client

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

payload = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/v3/blogs/:blogId/posts/:postId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

payload = {
    "author": {
        "displayName": "",
        "id": "",
        "image": { "url": "" },
        "url": ""
    },
    "blog": { "id": "" },
    "content": "",
    "customMetaData": "",
    "etag": "",
    "id": "",
    "images": [{ "url": "" }],
    "kind": "",
    "labels": [],
    "location": {
        "lat": "",
        "lng": "",
        "name": "",
        "span": ""
    },
    "published": "",
    "readerComments": "",
    "replies": {
        "items": [
            {
                "author": {
                    "displayName": "",
                    "id": "",
                    "image": { "url": "" },
                    "url": ""
                },
                "blog": { "id": "" },
                "content": "",
                "id": "",
                "inReplyTo": { "id": "" },
                "kind": "",
                "post": { "id": "" },
                "published": "",
                "selfLink": "",
                "status": "",
                "updated": ""
            }
        ],
        "selfLink": "",
        "totalItems": ""
    },
    "selfLink": "",
    "status": "",
    "title": "",
    "titleLink": "",
    "trashed": "",
    "updated": "",
    "url": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

payload <- "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/posts/:postId")

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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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/v3/blogs/:blogId/posts/:postId') do |req|
  req.body = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/posts/:postId";

    let payload = json!({
        "author": json!({
            "displayName": "",
            "id": "",
            "image": json!({"url": ""}),
            "url": ""
        }),
        "blog": json!({"id": ""}),
        "content": "",
        "customMetaData": "",
        "etag": "",
        "id": "",
        "images": (json!({"url": ""})),
        "kind": "",
        "labels": (),
        "location": json!({
            "lat": "",
            "lng": "",
            "name": "",
            "span": ""
        }),
        "published": "",
        "readerComments": "",
        "replies": json!({
            "items": (
                json!({
                    "author": json!({
                        "displayName": "",
                        "id": "",
                        "image": json!({"url": ""}),
                        "url": ""
                    }),
                    "blog": json!({"id": ""}),
                    "content": "",
                    "id": "",
                    "inReplyTo": json!({"id": ""}),
                    "kind": "",
                    "post": json!({"id": ""}),
                    "published": "",
                    "selfLink": "",
                    "status": "",
                    "updated": ""
                })
            ),
            "selfLink": "",
            "totalItems": ""
        }),
        "selfLink": "",
        "status": "",
        "title": "",
        "titleLink": "",
        "trashed": "",
        "updated": "",
        "url": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}' |  \
  http PATCH {{baseUrl}}/v3/blogs/:blogId/posts/:postId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "customMetaData": "",\n  "etag": "",\n  "id": "",\n  "images": [\n    {\n      "url": ""\n    }\n  ],\n  "kind": "",\n  "labels": [],\n  "location": {\n    "lat": "",\n    "lng": "",\n    "name": "",\n    "span": ""\n  },\n  "published": "",\n  "readerComments": "",\n  "replies": {\n    "items": [\n      {\n        "author": {\n          "displayName": "",\n          "id": "",\n          "image": {\n            "url": ""\n          },\n          "url": ""\n        },\n        "blog": {\n          "id": ""\n        },\n        "content": "",\n        "id": "",\n        "inReplyTo": {\n          "id": ""\n        },\n        "kind": "",\n        "post": {\n          "id": ""\n        },\n        "published": "",\n        "selfLink": "",\n        "status": "",\n        "updated": ""\n      }\n    ],\n    "selfLink": "",\n    "totalItems": ""\n  },\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "titleLink": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "author": [
    "displayName": "",
    "id": "",
    "image": ["url": ""],
    "url": ""
  ],
  "blog": ["id": ""],
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [["url": ""]],
  "kind": "",
  "labels": [],
  "location": [
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  ],
  "published": "",
  "readerComments": "",
  "replies": [
    "items": [
      [
        "author": [
          "displayName": "",
          "id": "",
          "image": ["url": ""],
          "url": ""
        ],
        "blog": ["id": ""],
        "content": "",
        "id": "",
        "inReplyTo": ["id": ""],
        "kind": "",
        "post": ["id": ""],
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      ]
    ],
    "selfLink": "",
    "totalItems": ""
  ],
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish"

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

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

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

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

}

POST /baseUrl/v3/blogs/:blogId/posts/:postId/publish HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/:postId/publish',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish');

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}}/v3/blogs/:blogId/posts/:postId/publish'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v3/blogs/:blogId/posts/:postId/publish")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v3/blogs/:blogId/posts/:postId/publish') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/publish")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert")

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert"

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

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

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

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

}

POST /baseUrl/v3/blogs/:blogId/posts/:postId/revert HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert'
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/:postId/revert',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert');

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}}/v3/blogs/:blogId/posts/:postId/revert'
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v3/blogs/:blogId/posts/:postId/revert")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v3/blogs/:blogId/posts/:postId/revert') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId/revert")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/search?q=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v3/blogs/:blogId/posts/search" {:query-params {:q ""}})

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/search?q="

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}}/v3/blogs/:blogId/posts/search?q="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/blogs/:blogId/posts/search?q=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/search?q="

	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/v3/blogs/:blogId/posts/search?q= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/blogs/:blogId/posts/search?q=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/search?q="))
    .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}}/v3/blogs/:blogId/posts/search?q=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v3/blogs/:blogId/posts/search?q=")
  .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}}/v3/blogs/:blogId/posts/search?q=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/search',
  params: {q: ''}
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/search?q=';
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}}/v3/blogs/:blogId/posts/search?q=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/search?q=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/search?q=',
  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}}/v3/blogs/:blogId/posts/search',
  qs: {q: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/blogs/:blogId/posts/search');

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

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}}/v3/blogs/:blogId/posts/search',
  params: {q: ''}
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/search?q=';
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}}/v3/blogs/:blogId/posts/search?q="]
                                                       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}}/v3/blogs/:blogId/posts/search?q=" in

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

 "{{baseUrl}}/v3/blogs/:blogId/posts/search?q=",
  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}}/v3/blogs/:blogId/posts/search?q=');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/search');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/search');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'q' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/search?q=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/search?q=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v3/blogs/:blogId/posts/search?q=")

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

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

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/search"

querystring = {"q":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/search"

queryString <- list(q = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/search?q=")

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/v3/blogs/:blogId/posts/search') do |req|
  req.params['q'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/blogs/:blogId/posts/search";

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

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/v3/blogs/:blogId/posts/search?q='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v3/blogs/:blogId/posts/search?q='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/search?q=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/blogs/:blogId/posts/:postId");

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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/v3/blogs/:blogId/posts/:postId" {:content-type :json
                                                                          :form-params {:author {:displayName ""
                                                                                                 :id ""
                                                                                                 :image {:url ""}
                                                                                                 :url ""}
                                                                                        :blog {:id ""}
                                                                                        :content ""
                                                                                        :customMetaData ""
                                                                                        :etag ""
                                                                                        :id ""
                                                                                        :images [{:url ""}]
                                                                                        :kind ""
                                                                                        :labels []
                                                                                        :location {:lat ""
                                                                                                   :lng ""
                                                                                                   :name ""
                                                                                                   :span ""}
                                                                                        :published ""
                                                                                        :readerComments ""
                                                                                        :replies {:items [{:author {:displayName ""
                                                                                                                    :id ""
                                                                                                                    :image {:url ""}
                                                                                                                    :url ""}
                                                                                                           :blog {:id ""}
                                                                                                           :content ""
                                                                                                           :id ""
                                                                                                           :inReplyTo {:id ""}
                                                                                                           :kind ""
                                                                                                           :post {:id ""}
                                                                                                           :published ""
                                                                                                           :selfLink ""
                                                                                                           :status ""
                                                                                                           :updated ""}]
                                                                                                  :selfLink ""
                                                                                                  :totalItems ""}
                                                                                        :selfLink ""
                                                                                        :status ""
                                                                                        :title ""
                                                                                        :titleLink ""
                                                                                        :trashed ""
                                                                                        :updated ""
                                                                                        :url ""}})

require "http/client"

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v3/blogs/:blogId/posts/:postId"),
    Content = new StringContent("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/posts/:postId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

	payload := strings.NewReader("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")

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

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

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

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

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

}

PUT /baseUrl/v3/blogs/:blogId/posts/:postId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1082

{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/blogs/:blogId/posts/:postId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .header("content-type", "application/json")
  .body("{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  customMetaData: '',
  etag: '',
  id: '',
  images: [
    {
      url: ''
    }
  ],
  kind: '',
  labels: [],
  location: {
    lat: '',
    lng: '',
    name: '',
    span: ''
  },
  published: '',
  readerComments: '',
  replies: {
    items: [
      {
        author: {
          displayName: '',
          id: '',
          image: {
            url: ''
          },
          url: ''
        },
        blog: {
          id: ''
        },
        content: '',
        id: '',
        inReplyTo: {
          id: ''
        },
        kind: '',
        post: {
          id: ''
        },
        published: '',
        selfLink: '',
        status: '',
        updated: ''
      }
    ],
    selfLink: '',
    totalItems: ''
  },
  selfLink: '',
  status: '',
  title: '',
  titleLink: '',
  trashed: '',
  updated: '',
  url: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    customMetaData: '',
    etag: '',
    id: '',
    images: [{url: ''}],
    kind: '',
    labels: [],
    location: {lat: '', lng: '', name: '', span: ''},
    published: '',
    readerComments: '',
    replies: {
      items: [
        {
          author: {displayName: '', id: '', image: {url: ''}, url: ''},
          blog: {id: ''},
          content: '',
          id: '',
          inReplyTo: {id: ''},
          kind: '',
          post: {id: ''},
          published: '',
          selfLink: '',
          status: '',
          updated: ''
        }
      ],
      selfLink: '',
      totalItems: ''
    },
    selfLink: '',
    status: '',
    title: '',
    titleLink: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","customMetaData":"","etag":"","id":"","images":[{"url":""}],"kind":"","labels":[],"location":{"lat":"","lng":"","name":"","span":""},"published":"","readerComments":"","replies":{"items":[{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","id":"","inReplyTo":{"id":""},"kind":"","post":{"id":""},"published":"","selfLink":"","status":"","updated":""}],"selfLink":"","totalItems":""},"selfLink":"","status":"","title":"","titleLink":"","trashed":"","updated":"","url":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "customMetaData": "",\n  "etag": "",\n  "id": "",\n  "images": [\n    {\n      "url": ""\n    }\n  ],\n  "kind": "",\n  "labels": [],\n  "location": {\n    "lat": "",\n    "lng": "",\n    "name": "",\n    "span": ""\n  },\n  "published": "",\n  "readerComments": "",\n  "replies": {\n    "items": [\n      {\n        "author": {\n          "displayName": "",\n          "id": "",\n          "image": {\n            "url": ""\n          },\n          "url": ""\n        },\n        "blog": {\n          "id": ""\n        },\n        "content": "",\n        "id": "",\n        "inReplyTo": {\n          "id": ""\n        },\n        "kind": "",\n        "post": {\n          "id": ""\n        },\n        "published": "",\n        "selfLink": "",\n        "status": "",\n        "updated": ""\n      }\n    ],\n    "selfLink": "",\n    "totalItems": ""\n  },\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "titleLink": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/blogs/:blogId/posts/:postId',
  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({
  author: {displayName: '', id: '', image: {url: ''}, url: ''},
  blog: {id: ''},
  content: '',
  customMetaData: '',
  etag: '',
  id: '',
  images: [{url: ''}],
  kind: '',
  labels: [],
  location: {lat: '', lng: '', name: '', span: ''},
  published: '',
  readerComments: '',
  replies: {
    items: [
      {
        author: {displayName: '', id: '', image: {url: ''}, url: ''},
        blog: {id: ''},
        content: '',
        id: '',
        inReplyTo: {id: ''},
        kind: '',
        post: {id: ''},
        published: '',
        selfLink: '',
        status: '',
        updated: ''
      }
    ],
    selfLink: '',
    totalItems: ''
  },
  selfLink: '',
  status: '',
  title: '',
  titleLink: '',
  trashed: '',
  updated: '',
  url: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId',
  headers: {'content-type': 'application/json'},
  body: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    customMetaData: '',
    etag: '',
    id: '',
    images: [{url: ''}],
    kind: '',
    labels: [],
    location: {lat: '', lng: '', name: '', span: ''},
    published: '',
    readerComments: '',
    replies: {
      items: [
        {
          author: {displayName: '', id: '', image: {url: ''}, url: ''},
          blog: {id: ''},
          content: '',
          id: '',
          inReplyTo: {id: ''},
          kind: '',
          post: {id: ''},
          published: '',
          selfLink: '',
          status: '',
          updated: ''
        }
      ],
      selfLink: '',
      totalItems: ''
    },
    selfLink: '',
    status: '',
    title: '',
    titleLink: '',
    trashed: '',
    updated: '',
    url: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId');

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

req.type('json');
req.send({
  author: {
    displayName: '',
    id: '',
    image: {
      url: ''
    },
    url: ''
  },
  blog: {
    id: ''
  },
  content: '',
  customMetaData: '',
  etag: '',
  id: '',
  images: [
    {
      url: ''
    }
  ],
  kind: '',
  labels: [],
  location: {
    lat: '',
    lng: '',
    name: '',
    span: ''
  },
  published: '',
  readerComments: '',
  replies: {
    items: [
      {
        author: {
          displayName: '',
          id: '',
          image: {
            url: ''
          },
          url: ''
        },
        blog: {
          id: ''
        },
        content: '',
        id: '',
        inReplyTo: {
          id: ''
        },
        kind: '',
        post: {
          id: ''
        },
        published: '',
        selfLink: '',
        status: '',
        updated: ''
      }
    ],
    selfLink: '',
    totalItems: ''
  },
  selfLink: '',
  status: '',
  title: '',
  titleLink: '',
  trashed: '',
  updated: '',
  url: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v3/blogs/:blogId/posts/:postId',
  headers: {'content-type': 'application/json'},
  data: {
    author: {displayName: '', id: '', image: {url: ''}, url: ''},
    blog: {id: ''},
    content: '',
    customMetaData: '',
    etag: '',
    id: '',
    images: [{url: ''}],
    kind: '',
    labels: [],
    location: {lat: '', lng: '', name: '', span: ''},
    published: '',
    readerComments: '',
    replies: {
      items: [
        {
          author: {displayName: '', id: '', image: {url: ''}, url: ''},
          blog: {id: ''},
          content: '',
          id: '',
          inReplyTo: {id: ''},
          kind: '',
          post: {id: ''},
          published: '',
          selfLink: '',
          status: '',
          updated: ''
        }
      ],
      selfLink: '',
      totalItems: ''
    },
    selfLink: '',
    status: '',
    title: '',
    titleLink: '',
    trashed: '',
    updated: '',
    url: ''
  }
};

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

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

const url = '{{baseUrl}}/v3/blogs/:blogId/posts/:postId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","customMetaData":"","etag":"","id":"","images":[{"url":""}],"kind":"","labels":[],"location":{"lat":"","lng":"","name":"","span":""},"published":"","readerComments":"","replies":{"items":[{"author":{"displayName":"","id":"","image":{"url":""},"url":""},"blog":{"id":""},"content":"","id":"","inReplyTo":{"id":""},"kind":"","post":{"id":""},"published":"","selfLink":"","status":"","updated":""}],"selfLink":"","totalItems":""},"selfLink":"","status":"","title":"","titleLink":"","trashed":"","updated":"","url":""}'
};

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 = @{ @"author": @{ @"displayName": @"", @"id": @"", @"image": @{ @"url": @"" }, @"url": @"" },
                              @"blog": @{ @"id": @"" },
                              @"content": @"",
                              @"customMetaData": @"",
                              @"etag": @"",
                              @"id": @"",
                              @"images": @[ @{ @"url": @"" } ],
                              @"kind": @"",
                              @"labels": @[  ],
                              @"location": @{ @"lat": @"", @"lng": @"", @"name": @"", @"span": @"" },
                              @"published": @"",
                              @"readerComments": @"",
                              @"replies": @{ @"items": @[ @{ @"author": @{ @"displayName": @"", @"id": @"", @"image": @{ @"url": @"" }, @"url": @"" }, @"blog": @{ @"id": @"" }, @"content": @"", @"id": @"", @"inReplyTo": @{ @"id": @"" }, @"kind": @"", @"post": @{ @"id": @"" }, @"published": @"", @"selfLink": @"", @"status": @"", @"updated": @"" } ], @"selfLink": @"", @"totalItems": @"" },
                              @"selfLink": @"",
                              @"status": @"",
                              @"title": @"",
                              @"titleLink": @"",
                              @"trashed": @"",
                              @"updated": @"",
                              @"url": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/blogs/:blogId/posts/:postId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/blogs/:blogId/posts/:postId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v3/blogs/:blogId/posts/:postId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'author' => [
        'displayName' => '',
        'id' => '',
        'image' => [
                'url' => ''
        ],
        'url' => ''
    ],
    'blog' => [
        'id' => ''
    ],
    'content' => '',
    'customMetaData' => '',
    'etag' => '',
    'id' => '',
    'images' => [
        [
                'url' => ''
        ]
    ],
    'kind' => '',
    'labels' => [
        
    ],
    'location' => [
        'lat' => '',
        'lng' => '',
        'name' => '',
        'span' => ''
    ],
    'published' => '',
    'readerComments' => '',
    'replies' => [
        'items' => [
                [
                                'author' => [
                                                                'displayName' => '',
                                                                'id' => '',
                                                                'image' => [
                                                                                                                                'url' => ''
                                                                ],
                                                                'url' => ''
                                ],
                                'blog' => [
                                                                'id' => ''
                                ],
                                'content' => '',
                                'id' => '',
                                'inReplyTo' => [
                                                                'id' => ''
                                ],
                                'kind' => '',
                                'post' => [
                                                                'id' => ''
                                ],
                                'published' => '',
                                'selfLink' => '',
                                'status' => '',
                                'updated' => ''
                ]
        ],
        'selfLink' => '',
        'totalItems' => ''
    ],
    'selfLink' => '',
    'status' => '',
    'title' => '',
    'titleLink' => '',
    'trashed' => '',
    'updated' => '',
    'url' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v3/blogs/:blogId/posts/:postId', [
  'body' => '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'customMetaData' => '',
  'etag' => '',
  'id' => '',
  'images' => [
    [
        'url' => ''
    ]
  ],
  'kind' => '',
  'labels' => [
    
  ],
  'location' => [
    'lat' => '',
    'lng' => '',
    'name' => '',
    'span' => ''
  ],
  'published' => '',
  'readerComments' => '',
  'replies' => [
    'items' => [
        [
                'author' => [
                                'displayName' => '',
                                'id' => '',
                                'image' => [
                                                                'url' => ''
                                ],
                                'url' => ''
                ],
                'blog' => [
                                'id' => ''
                ],
                'content' => '',
                'id' => '',
                'inReplyTo' => [
                                'id' => ''
                ],
                'kind' => '',
                'post' => [
                                'id' => ''
                ],
                'published' => '',
                'selfLink' => '',
                'status' => '',
                'updated' => ''
        ]
    ],
    'selfLink' => '',
    'totalItems' => ''
  ],
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'titleLink' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'author' => [
    'displayName' => '',
    'id' => '',
    'image' => [
        'url' => ''
    ],
    'url' => ''
  ],
  'blog' => [
    'id' => ''
  ],
  'content' => '',
  'customMetaData' => '',
  'etag' => '',
  'id' => '',
  'images' => [
    [
        'url' => ''
    ]
  ],
  'kind' => '',
  'labels' => [
    
  ],
  'location' => [
    'lat' => '',
    'lng' => '',
    'name' => '',
    'span' => ''
  ],
  'published' => '',
  'readerComments' => '',
  'replies' => [
    'items' => [
        [
                'author' => [
                                'displayName' => '',
                                'id' => '',
                                'image' => [
                                                                'url' => ''
                                ],
                                'url' => ''
                ],
                'blog' => [
                                'id' => ''
                ],
                'content' => '',
                'id' => '',
                'inReplyTo' => [
                                'id' => ''
                ],
                'kind' => '',
                'post' => [
                                'id' => ''
                ],
                'published' => '',
                'selfLink' => '',
                'status' => '',
                'updated' => ''
        ]
    ],
    'selfLink' => '',
    'totalItems' => ''
  ],
  'selfLink' => '',
  'status' => '',
  'title' => '',
  'titleLink' => '',
  'trashed' => '',
  'updated' => '',
  'url' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v3/blogs/:blogId/posts/:postId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/blogs/:blogId/posts/:postId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v3/blogs/:blogId/posts/:postId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

payload = {
    "author": {
        "displayName": "",
        "id": "",
        "image": { "url": "" },
        "url": ""
    },
    "blog": { "id": "" },
    "content": "",
    "customMetaData": "",
    "etag": "",
    "id": "",
    "images": [{ "url": "" }],
    "kind": "",
    "labels": [],
    "location": {
        "lat": "",
        "lng": "",
        "name": "",
        "span": ""
    },
    "published": "",
    "readerComments": "",
    "replies": {
        "items": [
            {
                "author": {
                    "displayName": "",
                    "id": "",
                    "image": { "url": "" },
                    "url": ""
                },
                "blog": { "id": "" },
                "content": "",
                "id": "",
                "inReplyTo": { "id": "" },
                "kind": "",
                "post": { "id": "" },
                "published": "",
                "selfLink": "",
                "status": "",
                "updated": ""
            }
        ],
        "selfLink": "",
        "totalItems": ""
    },
    "selfLink": "",
    "status": "",
    "title": "",
    "titleLink": "",
    "trashed": "",
    "updated": "",
    "url": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/blogs/:blogId/posts/:postId"

payload <- "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/blogs/:blogId/posts/:postId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/v3/blogs/:blogId/posts/:postId') do |req|
  req.body = "{\n  \"author\": {\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"image\": {\n      \"url\": \"\"\n    },\n    \"url\": \"\"\n  },\n  \"blog\": {\n    \"id\": \"\"\n  },\n  \"content\": \"\",\n  \"customMetaData\": \"\",\n  \"etag\": \"\",\n  \"id\": \"\",\n  \"images\": [\n    {\n      \"url\": \"\"\n    }\n  ],\n  \"kind\": \"\",\n  \"labels\": [],\n  \"location\": {\n    \"lat\": \"\",\n    \"lng\": \"\",\n    \"name\": \"\",\n    \"span\": \"\"\n  },\n  \"published\": \"\",\n  \"readerComments\": \"\",\n  \"replies\": {\n    \"items\": [\n      {\n        \"author\": {\n          \"displayName\": \"\",\n          \"id\": \"\",\n          \"image\": {\n            \"url\": \"\"\n          },\n          \"url\": \"\"\n        },\n        \"blog\": {\n          \"id\": \"\"\n        },\n        \"content\": \"\",\n        \"id\": \"\",\n        \"inReplyTo\": {\n          \"id\": \"\"\n        },\n        \"kind\": \"\",\n        \"post\": {\n          \"id\": \"\"\n        },\n        \"published\": \"\",\n        \"selfLink\": \"\",\n        \"status\": \"\",\n        \"updated\": \"\"\n      }\n    ],\n    \"selfLink\": \"\",\n    \"totalItems\": \"\"\n  },\n  \"selfLink\": \"\",\n  \"status\": \"\",\n  \"title\": \"\",\n  \"titleLink\": \"\",\n  \"trashed\": \"\",\n  \"updated\": \"\",\n  \"url\": \"\"\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}}/v3/blogs/:blogId/posts/:postId";

    let payload = json!({
        "author": json!({
            "displayName": "",
            "id": "",
            "image": json!({"url": ""}),
            "url": ""
        }),
        "blog": json!({"id": ""}),
        "content": "",
        "customMetaData": "",
        "etag": "",
        "id": "",
        "images": (json!({"url": ""})),
        "kind": "",
        "labels": (),
        "location": json!({
            "lat": "",
            "lng": "",
            "name": "",
            "span": ""
        }),
        "published": "",
        "readerComments": "",
        "replies": json!({
            "items": (
                json!({
                    "author": json!({
                        "displayName": "",
                        "id": "",
                        "image": json!({"url": ""}),
                        "url": ""
                    }),
                    "blog": json!({"id": ""}),
                    "content": "",
                    "id": "",
                    "inReplyTo": json!({"id": ""}),
                    "kind": "",
                    "post": json!({"id": ""}),
                    "published": "",
                    "selfLink": "",
                    "status": "",
                    "updated": ""
                })
            ),
            "selfLink": "",
            "totalItems": ""
        }),
        "selfLink": "",
        "status": "",
        "title": "",
        "titleLink": "",
        "trashed": "",
        "updated": "",
        "url": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "author": {
    "displayName": "",
    "id": "",
    "image": {
      "url": ""
    },
    "url": ""
  },
  "blog": {
    "id": ""
  },
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [
    {
      "url": ""
    }
  ],
  "kind": "",
  "labels": [],
  "location": {
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  },
  "published": "",
  "readerComments": "",
  "replies": {
    "items": [
      {
        "author": {
          "displayName": "",
          "id": "",
          "image": {
            "url": ""
          },
          "url": ""
        },
        "blog": {
          "id": ""
        },
        "content": "",
        "id": "",
        "inReplyTo": {
          "id": ""
        },
        "kind": "",
        "post": {
          "id": ""
        },
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      }
    ],
    "selfLink": "",
    "totalItems": ""
  },
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
}' |  \
  http PUT {{baseUrl}}/v3/blogs/:blogId/posts/:postId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "author": {\n    "displayName": "",\n    "id": "",\n    "image": {\n      "url": ""\n    },\n    "url": ""\n  },\n  "blog": {\n    "id": ""\n  },\n  "content": "",\n  "customMetaData": "",\n  "etag": "",\n  "id": "",\n  "images": [\n    {\n      "url": ""\n    }\n  ],\n  "kind": "",\n  "labels": [],\n  "location": {\n    "lat": "",\n    "lng": "",\n    "name": "",\n    "span": ""\n  },\n  "published": "",\n  "readerComments": "",\n  "replies": {\n    "items": [\n      {\n        "author": {\n          "displayName": "",\n          "id": "",\n          "image": {\n            "url": ""\n          },\n          "url": ""\n        },\n        "blog": {\n          "id": ""\n        },\n        "content": "",\n        "id": "",\n        "inReplyTo": {\n          "id": ""\n        },\n        "kind": "",\n        "post": {\n          "id": ""\n        },\n        "published": "",\n        "selfLink": "",\n        "status": "",\n        "updated": ""\n      }\n    ],\n    "selfLink": "",\n    "totalItems": ""\n  },\n  "selfLink": "",\n  "status": "",\n  "title": "",\n  "titleLink": "",\n  "trashed": "",\n  "updated": "",\n  "url": ""\n}' \
  --output-document \
  - {{baseUrl}}/v3/blogs/:blogId/posts/:postId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "author": [
    "displayName": "",
    "id": "",
    "image": ["url": ""],
    "url": ""
  ],
  "blog": ["id": ""],
  "content": "",
  "customMetaData": "",
  "etag": "",
  "id": "",
  "images": [["url": ""]],
  "kind": "",
  "labels": [],
  "location": [
    "lat": "",
    "lng": "",
    "name": "",
    "span": ""
  ],
  "published": "",
  "readerComments": "",
  "replies": [
    "items": [
      [
        "author": [
          "displayName": "",
          "id": "",
          "image": ["url": ""],
          "url": ""
        ],
        "blog": ["id": ""],
        "content": "",
        "id": "",
        "inReplyTo": ["id": ""],
        "kind": "",
        "post": ["id": ""],
        "published": "",
        "selfLink": "",
        "status": "",
        "updated": ""
      ]
    ],
    "selfLink": "",
    "totalItems": ""
  ],
  "selfLink": "",
  "status": "",
  "title": "",
  "titleLink": "",
  "trashed": "",
  "updated": "",
  "url": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/blogs/:blogId/posts/:postId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId")

require "http/client"

url = "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId"

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}}/v3/users/:userId/blogs/:blogId/posts/:postId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId"

	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/v3/users/:userId/blogs/:blogId/posts/:postId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId"))
    .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}}/v3/users/:userId/blogs/:blogId/posts/:postId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId")
  .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}}/v3/users/:userId/blogs/:blogId/posts/:postId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId';
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}}/v3/users/:userId/blogs/:blogId/posts/:postId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/users/:userId/blogs/:blogId/posts/:postId',
  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}}/v3/users/:userId/blogs/:blogId/posts/:postId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId');

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}}/v3/users/:userId/blogs/:blogId/posts/:postId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId';
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}}/v3/users/:userId/blogs/:blogId/posts/:postId"]
                                                       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}}/v3/users/:userId/blogs/:blogId/posts/:postId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId",
  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}}/v3/users/:userId/blogs/:blogId/posts/:postId');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/users/:userId/blogs/:blogId/posts/:postId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId")

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/v3/users/:userId/blogs/:blogId/posts/:postId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts/:postId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts")

require "http/client"

url = "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts"

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}}/v3/users/:userId/blogs/:blogId/posts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts"

	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/v3/users/:userId/blogs/:blogId/posts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts"))
    .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}}/v3/users/:userId/blogs/:blogId/posts")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts")
  .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}}/v3/users/:userId/blogs/:blogId/posts');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts';
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}}/v3/users/:userId/blogs/:blogId/posts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/users/:userId/blogs/:blogId/posts',
  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}}/v3/users/:userId/blogs/:blogId/posts'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts');

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}}/v3/users/:userId/blogs/:blogId/posts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts';
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}}/v3/users/:userId/blogs/:blogId/posts"]
                                                       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}}/v3/users/:userId/blogs/:blogId/posts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts",
  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}}/v3/users/:userId/blogs/:blogId/posts');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/users/:userId/blogs/:blogId/posts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts")

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/v3/users/:userId/blogs/:blogId/posts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v3/users/:userId/blogs/:blogId/posts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/users/:userId/blogs/:blogId/posts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/users/:userId/blogs/:blogId/posts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v3/users/:userId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v3/users/:userId")

require "http/client"

url = "{{baseUrl}}/v3/users/:userId"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v3/users/:userId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v3/users/:userId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v3/users/:userId"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v3/users/:userId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v3/users/:userId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v3/users/:userId"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v3/users/:userId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v3/users/:userId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v3/users/:userId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v3/users/:userId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v3/users/:userId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v3/users/:userId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v3/users/:userId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v3/users/:userId',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v3/users/:userId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v3/users/:userId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v3/users/:userId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v3/users/:userId';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v3/users/:userId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v3/users/:userId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v3/users/:userId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v3/users/:userId');

echo $response->getBody();

setUrl('{{baseUrl}}/v3/users/:userId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v3/users/:userId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v3/users/:userId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v3/users/:userId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v3/users/:userId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v3/users/:userId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v3/users/:userId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v3/users/:userId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v3/users/:userId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v3/users/:userId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v3/users/:userId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v3/users/:userId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v3/users/:userId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()