Google Mirror

POST mirror.accounts.insert

{{baseUrl}}/accounts/:userToken/:accountType/:accountName

QUERY PARAMS

userToken

accountType

accountName

BODY json

{
  "authTokens": [
    {
      "authToken": "",
      "type": ""
    }
  ],
  "features": [],
  "password": "",
  "userData": [
    {
      "key": "",
      "value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accounts/:userToken/:accountType/:accountName");

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  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/accounts/:userToken/:accountType/:accountName" {:content-type :json
                                                                                          :form-params {:authTokens [{:authToken ""
                                                                                                                      :type ""}]
                                                                                                        :features []
                                                                                                        :password ""
                                                                                                        :userData [{:key ""
                                                                                                                    :value ""}]}})

require "http/client"

url = "{{baseUrl}}/accounts/:userToken/:accountType/:accountName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/accounts/:userToken/:accountType/:accountName"),
    Content = new StringContent("{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accounts/:userToken/:accountType/:accountName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accounts/:userToken/:accountType/:accountName"

	payload := strings.NewReader("{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/accounts/:userToken/:accountType/:accountName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 181

{
  "authTokens": [
    {
      "authToken": "",
      "type": ""
    }
  ],
  "features": [],
  "password": "",
  "userData": [
    {
      "key": "",
      "value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/accounts/:userToken/:accountType/:accountName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accounts/:userToken/:accountType/:accountName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/accounts/:userToken/:accountType/:accountName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/accounts/:userToken/:accountType/:accountName")
  .header("content-type", "application/json")
  .body("{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  authTokens: [
    {
      authToken: '',
      type: ''
    }
  ],
  features: [],
  password: '',
  userData: [
    {
      key: '',
      value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/accounts/:userToken/:accountType/:accountName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:userToken/:accountType/:accountName',
  headers: {'content-type': 'application/json'},
  data: {
    authTokens: [{authToken: '', type: ''}],
    features: [],
    password: '',
    userData: [{key: '', value: ''}]
  }
};

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

const url = '{{baseUrl}}/accounts/:userToken/:accountType/:accountName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authTokens":[{"authToken":"","type":""}],"features":[],"password":"","userData":[{"key":"","value":""}]}'
};

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}}/accounts/:userToken/:accountType/:accountName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authTokens": [\n    {\n      "authToken": "",\n      "type": ""\n    }\n  ],\n  "features": [],\n  "password": "",\n  "userData": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/accounts/:userToken/:accountType/:accountName")
  .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/accounts/:userToken/:accountType/:accountName',
  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({
  authTokens: [{authToken: '', type: ''}],
  features: [],
  password: '',
  userData: [{key: '', value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/accounts/:userToken/:accountType/:accountName',
  headers: {'content-type': 'application/json'},
  body: {
    authTokens: [{authToken: '', type: ''}],
    features: [],
    password: '',
    userData: [{key: '', value: ''}]
  },
  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}}/accounts/:userToken/:accountType/:accountName');

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

req.type('json');
req.send({
  authTokens: [
    {
      authToken: '',
      type: ''
    }
  ],
  features: [],
  password: '',
  userData: [
    {
      key: '',
      value: ''
    }
  ]
});

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}}/accounts/:userToken/:accountType/:accountName',
  headers: {'content-type': 'application/json'},
  data: {
    authTokens: [{authToken: '', type: ''}],
    features: [],
    password: '',
    userData: [{key: '', value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/accounts/:userToken/:accountType/:accountName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authTokens":[{"authToken":"","type":""}],"features":[],"password":"","userData":[{"key":"","value":""}]}'
};

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 = @{ @"authTokens": @[ @{ @"authToken": @"", @"type": @"" } ],
                              @"features": @[  ],
                              @"password": @"",
                              @"userData": @[ @{ @"key": @"", @"value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accounts/:userToken/:accountType/:accountName"]
                                                       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}}/accounts/:userToken/:accountType/:accountName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/accounts/:userToken/:accountType/:accountName",
  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([
    'authTokens' => [
        [
                'authToken' => '',
                'type' => ''
        ]
    ],
    'features' => [
        
    ],
    'password' => '',
    'userData' => [
        [
                'key' => '',
                'value' => ''
        ]
    ]
  ]),
  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}}/accounts/:userToken/:accountType/:accountName', [
  'body' => '{
  "authTokens": [
    {
      "authToken": "",
      "type": ""
    }
  ],
  "features": [],
  "password": "",
  "userData": [
    {
      "key": "",
      "value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/accounts/:userToken/:accountType/:accountName');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authTokens' => [
    [
        'authToken' => '',
        'type' => ''
    ]
  ],
  'features' => [
    
  ],
  'password' => '',
  'userData' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'authTokens' => [
    [
        'authToken' => '',
        'type' => ''
    ]
  ],
  'features' => [
    
  ],
  'password' => '',
  'userData' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/accounts/:userToken/:accountType/:accountName');
$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}}/accounts/:userToken/:accountType/:accountName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authTokens": [
    {
      "authToken": "",
      "type": ""
    }
  ],
  "features": [],
  "password": "",
  "userData": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/accounts/:userToken/:accountType/:accountName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authTokens": [
    {
      "authToken": "",
      "type": ""
    }
  ],
  "features": [],
  "password": "",
  "userData": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/accounts/:userToken/:accountType/:accountName", payload, headers)

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

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

import requests

url = "{{baseUrl}}/accounts/:userToken/:accountType/:accountName"

payload = {
    "authTokens": [
        {
            "authToken": "",
            "type": ""
        }
    ],
    "features": [],
    "password": "",
    "userData": [
        {
            "key": "",
            "value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/accounts/:userToken/:accountType/:accountName"

payload <- "{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accounts/:userToken/:accountType/:accountName")

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  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/accounts/:userToken/:accountType/:accountName') do |req|
  req.body = "{\n  \"authTokens\": [\n    {\n      \"authToken\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"features\": [],\n  \"password\": \"\",\n  \"userData\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accounts/:userToken/:accountType/:accountName";

    let payload = json!({
        "authTokens": (
            json!({
                "authToken": "",
                "type": ""
            })
        ),
        "features": (),
        "password": "",
        "userData": (
            json!({
                "key": "",
                "value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/accounts/:userToken/:accountType/:accountName \
  --header 'content-type: application/json' \
  --data '{
  "authTokens": [
    {
      "authToken": "",
      "type": ""
    }
  ],
  "features": [],
  "password": "",
  "userData": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

echo '{
  "authTokens": [
    {
      "authToken": "",
      "type": ""
    }
  ],
  "features": [],
  "password": "",
  "userData": [
    {
      "key": "",
      "value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/accounts/:userToken/:accountType/:accountName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authTokens": [\n    {\n      "authToken": "",\n      "type": ""\n    }\n  ],\n  "features": [],\n  "password": "",\n  "userData": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/accounts/:userToken/:accountType/:accountName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authTokens": [
    [
      "authToken": "",
      "type": ""
    ]
  ],
  "features": [],
  "password": "",
  "userData": [
    [
      "key": "",
      "value": ""
    ]
  ]
] as [String : Any]

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

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

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

dataTask.resume()

DELETE mirror.contacts.delete

{{baseUrl}}/contacts/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/contacts/:id")

require "http/client"

url = "{{baseUrl}}/contacts/:id"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/contacts/:id"

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

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

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

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

}

DELETE /baseUrl/contacts/:id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/contacts/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/contacts/:id'};

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

const url = '{{baseUrl}}/contacts/:id';
const options = {method: 'DELETE'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/contacts/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

const options = {method: 'DELETE', url: '{{baseUrl}}/contacts/:id'};

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

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

const url = '{{baseUrl}}/contacts/:id';
const options = {method: 'DELETE'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/contacts/:id" in

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

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

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/contacts/:id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/contacts/:id")

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

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

import requests

url = "{{baseUrl}}/contacts/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts/:id")

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/contacts/:id

http DELETE {{baseUrl}}/contacts/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/contacts/:id

import Foundation

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

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

dataTask.resume()

GET mirror.contacts.get

{{baseUrl}}/contacts/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/contacts/:id")

require "http/client"

url = "{{baseUrl}}/contacts/:id"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/contacts/:id"

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

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

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

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

}

GET /baseUrl/contacts/:id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/contacts/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/contacts/:id")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/contacts/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/contacts/:id'};

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

const url = '{{baseUrl}}/contacts/:id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/contacts/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contacts/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contacts/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/contacts/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/contacts/:id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/contacts/:id'};

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

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

const url = '{{baseUrl}}/contacts/:id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/contacts/:id" in

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

 "{{baseUrl}}/contacts/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/contacts/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/:id');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/contacts/:id")

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

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

import requests

url = "{{baseUrl}}/contacts/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts/:id")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/contacts/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/contacts/:id

http GET {{baseUrl}}/contacts/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/contacts/:id

import Foundation

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

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

dataTask.resume()

POST mirror.contacts.insert

{{baseUrl}}/contacts

BODY json

{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts");

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  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/contacts" {:content-type :json
                                                     :form-params {:acceptCommands [{:type ""}]
                                                                   :acceptTypes []
                                                                   :displayName ""
                                                                   :id ""
                                                                   :imageUrls []
                                                                   :kind ""
                                                                   :phoneNumber ""
                                                                   :priority 0
                                                                   :sharingFeatures []
                                                                   :source ""
                                                                   :speakableName ""
                                                                   :type ""}})

require "http/client"

url = "{{baseUrl}}/contacts"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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}}/contacts"),
    Content = new StringContent("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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}}/contacts");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/contacts"

	payload := strings.NewReader("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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/contacts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 261

{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contacts")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contacts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/contacts")
  .header("content-type", "application/json")
  .body("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  acceptCommands: [
    {
      type: ''
    }
  ],
  acceptTypes: [],
  displayName: '',
  id: '',
  imageUrls: [],
  kind: '',
  phoneNumber: '',
  priority: 0,
  sharingFeatures: [],
  source: '',
  speakableName: '',
  type: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/contacts');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contacts',
  headers: {'content-type': 'application/json'},
  data: {
    acceptCommands: [{type: ''}],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  }
};

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

const url = '{{baseUrl}}/contacts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"acceptCommands":[{"type":""}],"acceptTypes":[],"displayName":"","id":"","imageUrls":[],"kind":"","phoneNumber":"","priority":0,"sharingFeatures":[],"source":"","speakableName":"","type":""}'
};

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}}/contacts',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "acceptCommands": [\n    {\n      "type": ""\n    }\n  ],\n  "acceptTypes": [],\n  "displayName": "",\n  "id": "",\n  "imageUrls": [],\n  "kind": "",\n  "phoneNumber": "",\n  "priority": 0,\n  "sharingFeatures": [],\n  "source": "",\n  "speakableName": "",\n  "type": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contacts")
  .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/contacts',
  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({
  acceptCommands: [{type: ''}],
  acceptTypes: [],
  displayName: '',
  id: '',
  imageUrls: [],
  kind: '',
  phoneNumber: '',
  priority: 0,
  sharingFeatures: [],
  source: '',
  speakableName: '',
  type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contacts',
  headers: {'content-type': 'application/json'},
  body: {
    acceptCommands: [{type: ''}],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  },
  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}}/contacts');

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

req.type('json');
req.send({
  acceptCommands: [
    {
      type: ''
    }
  ],
  acceptTypes: [],
  displayName: '',
  id: '',
  imageUrls: [],
  kind: '',
  phoneNumber: '',
  priority: 0,
  sharingFeatures: [],
  source: '',
  speakableName: '',
  type: ''
});

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}}/contacts',
  headers: {'content-type': 'application/json'},
  data: {
    acceptCommands: [{type: ''}],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  }
};

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

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

const url = '{{baseUrl}}/contacts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"acceptCommands":[{"type":""}],"acceptTypes":[],"displayName":"","id":"","imageUrls":[],"kind":"","phoneNumber":"","priority":0,"sharingFeatures":[],"source":"","speakableName":"","type":""}'
};

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 = @{ @"acceptCommands": @[ @{ @"type": @"" } ],
                              @"acceptTypes": @[  ],
                              @"displayName": @"",
                              @"id": @"",
                              @"imageUrls": @[  ],
                              @"kind": @"",
                              @"phoneNumber": @"",
                              @"priority": @0,
                              @"sharingFeatures": @[  ],
                              @"source": @"",
                              @"speakableName": @"",
                              @"type": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts"]
                                                       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}}/contacts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}" in

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

 "{{baseUrl}}/contacts",
  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([
    'acceptCommands' => [
        [
                'type' => ''
        ]
    ],
    'acceptTypes' => [
        
    ],
    'displayName' => '',
    'id' => '',
    'imageUrls' => [
        
    ],
    'kind' => '',
    'phoneNumber' => '',
    'priority' => 0,
    'sharingFeatures' => [
        
    ],
    'source' => '',
    'speakableName' => '',
    'type' => ''
  ]),
  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}}/contacts', [
  'body' => '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'acceptCommands' => [
    [
        'type' => ''
    ]
  ],
  'acceptTypes' => [
    
  ],
  'displayName' => '',
  'id' => '',
  'imageUrls' => [
    
  ],
  'kind' => '',
  'phoneNumber' => '',
  'priority' => 0,
  'sharingFeatures' => [
    
  ],
  'source' => '',
  'speakableName' => '',
  'type' => ''
]));

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

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

append(json_encode([
  'acceptCommands' => [
    [
        'type' => ''
    ]
  ],
  'acceptTypes' => [
    
  ],
  'displayName' => '',
  'id' => '',
  'imageUrls' => [
    
  ],
  'kind' => '',
  'phoneNumber' => '',
  'priority' => 0,
  'sharingFeatures' => [
    
  ],
  'source' => '',
  'speakableName' => '',
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/contacts');
$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}}/contacts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}'

import http.client

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

payload = "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}"

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

conn.request("POST", "/baseUrl/contacts", payload, headers)

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

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

import requests

url = "{{baseUrl}}/contacts"

payload = {
    "acceptCommands": [{ "type": "" }],
    "acceptTypes": [],
    "displayName": "",
    "id": "",
    "imageUrls": [],
    "kind": "",
    "phoneNumber": "",
    "priority": 0,
    "sharingFeatures": [],
    "source": "",
    "speakableName": "",
    "type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts"

payload <- "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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}}/contacts")

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  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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/contacts') do |req|
  req.body = "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "acceptCommands": (json!({"type": ""})),
        "acceptTypes": (),
        "displayName": "",
        "id": "",
        "imageUrls": (),
        "kind": "",
        "phoneNumber": "",
        "priority": 0,
        "sharingFeatures": (),
        "source": "",
        "speakableName": "",
        "type": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/contacts \
  --header 'content-type: application/json' \
  --data '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}'

echo '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}' |  \
  http POST {{baseUrl}}/contacts \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "acceptCommands": [\n    {\n      "type": ""\n    }\n  ],\n  "acceptTypes": [],\n  "displayName": "",\n  "id": "",\n  "imageUrls": [],\n  "kind": "",\n  "phoneNumber": "",\n  "priority": 0,\n  "sharingFeatures": [],\n  "source": "",\n  "speakableName": "",\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/contacts

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "acceptCommands": [["type": ""]],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
] as [String : Any]

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

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

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

dataTask.resume()

GET mirror.contacts.list

{{baseUrl}}/contacts

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/contacts")

require "http/client"

url = "{{baseUrl}}/contacts"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/contacts"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/contacts'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/contacts")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/contacts');

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}}/contacts'};

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

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

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

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

 "{{baseUrl}}/contacts",
  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}}/contacts');

echo $response->getBody();

setUrl('{{baseUrl}}/contacts');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/contacts")

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

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

import requests

url = "{{baseUrl}}/contacts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contacts")

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/contacts') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/contacts

http GET {{baseUrl}}/contacts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/contacts

import Foundation

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

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

dataTask.resume()

PATCH mirror.contacts.patch

{{baseUrl}}/contacts/:id

QUERY PARAMS

BODY json

{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/contacts/:id" {:content-type :json
                                                          :form-params {:acceptCommands [{:type ""}]
                                                                        :acceptTypes []
                                                                        :displayName ""
                                                                        :id ""
                                                                        :imageUrls []
                                                                        :kind ""
                                                                        :phoneNumber ""
                                                                        :priority 0
                                                                        :sharingFeatures []
                                                                        :source ""
                                                                        :speakableName ""
                                                                        :type ""}})

require "http/client"

url = "{{baseUrl}}/contacts/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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}}/contacts/:id"),
    Content = new StringContent("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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}}/contacts/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/contacts/:id"

	payload := strings.NewReader("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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/contacts/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 261

{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/contacts/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contacts/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/contacts/:id")
  .header("content-type", "application/json")
  .body("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  acceptCommands: [
    {
      type: ''
    }
  ],
  acceptTypes: [],
  displayName: '',
  id: '',
  imageUrls: [],
  kind: '',
  phoneNumber: '',
  priority: 0,
  sharingFeatures: [],
  source: '',
  speakableName: '',
  type: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/contacts/:id',
  headers: {'content-type': 'application/json'},
  data: {
    acceptCommands: [{type: ''}],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  }
};

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

const url = '{{baseUrl}}/contacts/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"acceptCommands":[{"type":""}],"acceptTypes":[],"displayName":"","id":"","imageUrls":[],"kind":"","phoneNumber":"","priority":0,"sharingFeatures":[],"source":"","speakableName":"","type":""}'
};

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}}/contacts/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "acceptCommands": [\n    {\n      "type": ""\n    }\n  ],\n  "acceptTypes": [],\n  "displayName": "",\n  "id": "",\n  "imageUrls": [],\n  "kind": "",\n  "phoneNumber": "",\n  "priority": 0,\n  "sharingFeatures": [],\n  "source": "",\n  "speakableName": "",\n  "type": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contacts/:id")
  .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/contacts/:id',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  acceptCommands: [{type: ''}],
  acceptTypes: [],
  displayName: '',
  id: '',
  imageUrls: [],
  kind: '',
  phoneNumber: '',
  priority: 0,
  sharingFeatures: [],
  source: '',
  speakableName: '',
  type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/contacts/:id',
  headers: {'content-type': 'application/json'},
  body: {
    acceptCommands: [{type: ''}],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  },
  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}}/contacts/:id');

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

req.type('json');
req.send({
  acceptCommands: [
    {
      type: ''
    }
  ],
  acceptTypes: [],
  displayName: '',
  id: '',
  imageUrls: [],
  kind: '',
  phoneNumber: '',
  priority: 0,
  sharingFeatures: [],
  source: '',
  speakableName: '',
  type: ''
});

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}}/contacts/:id',
  headers: {'content-type': 'application/json'},
  data: {
    acceptCommands: [{type: ''}],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  }
};

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

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

const url = '{{baseUrl}}/contacts/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"acceptCommands":[{"type":""}],"acceptTypes":[],"displayName":"","id":"","imageUrls":[],"kind":"","phoneNumber":"","priority":0,"sharingFeatures":[],"source":"","speakableName":"","type":""}'
};

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 = @{ @"acceptCommands": @[ @{ @"type": @"" } ],
                              @"acceptTypes": @[  ],
                              @"displayName": @"",
                              @"id": @"",
                              @"imageUrls": @[  ],
                              @"kind": @"",
                              @"phoneNumber": @"",
                              @"priority": @0,
                              @"sharingFeatures": @[  ],
                              @"source": @"",
                              @"speakableName": @"",
                              @"type": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts/:id"]
                                                       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}}/contacts/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}" in

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

 "{{baseUrl}}/contacts/:id",
  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([
    'acceptCommands' => [
        [
                'type' => ''
        ]
    ],
    'acceptTypes' => [
        
    ],
    'displayName' => '',
    'id' => '',
    'imageUrls' => [
        
    ],
    'kind' => '',
    'phoneNumber' => '',
    'priority' => 0,
    'sharingFeatures' => [
        
    ],
    'source' => '',
    'speakableName' => '',
    'type' => ''
  ]),
  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}}/contacts/:id', [
  'body' => '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'acceptCommands' => [
    [
        'type' => ''
    ]
  ],
  'acceptTypes' => [
    
  ],
  'displayName' => '',
  'id' => '',
  'imageUrls' => [
    
  ],
  'kind' => '',
  'phoneNumber' => '',
  'priority' => 0,
  'sharingFeatures' => [
    
  ],
  'source' => '',
  'speakableName' => '',
  'type' => ''
]));

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

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

append(json_encode([
  'acceptCommands' => [
    [
        'type' => ''
    ]
  ],
  'acceptTypes' => [
    
  ],
  'displayName' => '',
  'id' => '',
  'imageUrls' => [
    
  ],
  'kind' => '',
  'phoneNumber' => '',
  'priority' => 0,
  'sharingFeatures' => [
    
  ],
  'source' => '',
  'speakableName' => '',
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/contacts/:id');
$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}}/contacts/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}'

import http.client

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

payload = "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/contacts/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/contacts/:id"

payload = {
    "acceptCommands": [{ "type": "" }],
    "acceptTypes": [],
    "displayName": "",
    "id": "",
    "imageUrls": [],
    "kind": "",
    "phoneNumber": "",
    "priority": 0,
    "sharingFeatures": [],
    "source": "",
    "speakableName": "",
    "type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:id"

payload <- "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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}}/contacts/:id")

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  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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/contacts/:id') do |req|
  req.body = "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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}}/contacts/:id";

    let payload = json!({
        "acceptCommands": (json!({"type": ""})),
        "acceptTypes": (),
        "displayName": "",
        "id": "",
        "imageUrls": (),
        "kind": "",
        "phoneNumber": "",
        "priority": 0,
        "sharingFeatures": (),
        "source": "",
        "speakableName": "",
        "type": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/contacts/:id \
  --header 'content-type: application/json' \
  --data '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}'

echo '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}' |  \
  http PATCH {{baseUrl}}/contacts/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "acceptCommands": [\n    {\n      "type": ""\n    }\n  ],\n  "acceptTypes": [],\n  "displayName": "",\n  "id": "",\n  "imageUrls": [],\n  "kind": "",\n  "phoneNumber": "",\n  "priority": 0,\n  "sharingFeatures": [],\n  "source": "",\n  "speakableName": "",\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/contacts/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "acceptCommands": [["type": ""]],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
] as [String : Any]

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

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

PUT mirror.contacts.update

{{baseUrl}}/contacts/:id

QUERY PARAMS

BODY json

{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contacts/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/contacts/:id" {:content-type :json
                                                        :form-params {:acceptCommands [{:type ""}]
                                                                      :acceptTypes []
                                                                      :displayName ""
                                                                      :id ""
                                                                      :imageUrls []
                                                                      :kind ""
                                                                      :phoneNumber ""
                                                                      :priority 0
                                                                      :sharingFeatures []
                                                                      :source ""
                                                                      :speakableName ""
                                                                      :type ""}})

require "http/client"

url = "{{baseUrl}}/contacts/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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}}/contacts/:id"),
    Content = new StringContent("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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}}/contacts/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/contacts/:id"

	payload := strings.NewReader("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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/contacts/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 261

{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/contacts/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contacts/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/contacts/:id")
  .header("content-type", "application/json")
  .body("{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  acceptCommands: [
    {
      type: ''
    }
  ],
  acceptTypes: [],
  displayName: '',
  id: '',
  imageUrls: [],
  kind: '',
  phoneNumber: '',
  priority: 0,
  sharingFeatures: [],
  source: '',
  speakableName: '',
  type: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/contacts/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/contacts/:id',
  headers: {'content-type': 'application/json'},
  data: {
    acceptCommands: [{type: ''}],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  }
};

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

const url = '{{baseUrl}}/contacts/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"acceptCommands":[{"type":""}],"acceptTypes":[],"displayName":"","id":"","imageUrls":[],"kind":"","phoneNumber":"","priority":0,"sharingFeatures":[],"source":"","speakableName":"","type":""}'
};

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}}/contacts/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "acceptCommands": [\n    {\n      "type": ""\n    }\n  ],\n  "acceptTypes": [],\n  "displayName": "",\n  "id": "",\n  "imageUrls": [],\n  "kind": "",\n  "phoneNumber": "",\n  "priority": 0,\n  "sharingFeatures": [],\n  "source": "",\n  "speakableName": "",\n  "type": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contacts/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/contacts/:id',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  acceptCommands: [{type: ''}],
  acceptTypes: [],
  displayName: '',
  id: '',
  imageUrls: [],
  kind: '',
  phoneNumber: '',
  priority: 0,
  sharingFeatures: [],
  source: '',
  speakableName: '',
  type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/contacts/:id',
  headers: {'content-type': 'application/json'},
  body: {
    acceptCommands: [{type: ''}],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  },
  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}}/contacts/:id');

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

req.type('json');
req.send({
  acceptCommands: [
    {
      type: ''
    }
  ],
  acceptTypes: [],
  displayName: '',
  id: '',
  imageUrls: [],
  kind: '',
  phoneNumber: '',
  priority: 0,
  sharingFeatures: [],
  source: '',
  speakableName: '',
  type: ''
});

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}}/contacts/:id',
  headers: {'content-type': 'application/json'},
  data: {
    acceptCommands: [{type: ''}],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  }
};

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

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

const url = '{{baseUrl}}/contacts/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"acceptCommands":[{"type":""}],"acceptTypes":[],"displayName":"","id":"","imageUrls":[],"kind":"","phoneNumber":"","priority":0,"sharingFeatures":[],"source":"","speakableName":"","type":""}'
};

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 = @{ @"acceptCommands": @[ @{ @"type": @"" } ],
                              @"acceptTypes": @[  ],
                              @"displayName": @"",
                              @"id": @"",
                              @"imageUrls": @[  ],
                              @"kind": @"",
                              @"phoneNumber": @"",
                              @"priority": @0,
                              @"sharingFeatures": @[  ],
                              @"source": @"",
                              @"speakableName": @"",
                              @"type": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contacts/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/contacts/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}" in

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

 "{{baseUrl}}/contacts/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'acceptCommands' => [
        [
                'type' => ''
        ]
    ],
    'acceptTypes' => [
        
    ],
    'displayName' => '',
    'id' => '',
    'imageUrls' => [
        
    ],
    'kind' => '',
    'phoneNumber' => '',
    'priority' => 0,
    'sharingFeatures' => [
        
    ],
    'source' => '',
    'speakableName' => '',
    'type' => ''
  ]),
  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}}/contacts/:id', [
  'body' => '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contacts/:id');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'acceptCommands' => [
    [
        'type' => ''
    ]
  ],
  'acceptTypes' => [
    
  ],
  'displayName' => '',
  'id' => '',
  'imageUrls' => [
    
  ],
  'kind' => '',
  'phoneNumber' => '',
  'priority' => 0,
  'sharingFeatures' => [
    
  ],
  'source' => '',
  'speakableName' => '',
  'type' => ''
]));

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

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

append(json_encode([
  'acceptCommands' => [
    [
        'type' => ''
    ]
  ],
  'acceptTypes' => [
    
  ],
  'displayName' => '',
  'id' => '',
  'imageUrls' => [
    
  ],
  'kind' => '',
  'phoneNumber' => '',
  'priority' => 0,
  'sharingFeatures' => [
    
  ],
  'source' => '',
  'speakableName' => '',
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/contacts/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}'

import http.client

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

payload = "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/contacts/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/contacts/:id"

payload = {
    "acceptCommands": [{ "type": "" }],
    "acceptTypes": [],
    "displayName": "",
    "id": "",
    "imageUrls": [],
    "kind": "",
    "phoneNumber": "",
    "priority": 0,
    "sharingFeatures": [],
    "source": "",
    "speakableName": "",
    "type": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/contacts/:id"

payload <- "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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}}/contacts/:id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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/contacts/:id') do |req|
  req.body = "{\n  \"acceptCommands\": [\n    {\n      \"type\": \"\"\n    }\n  ],\n  \"acceptTypes\": [],\n  \"displayName\": \"\",\n  \"id\": \"\",\n  \"imageUrls\": [],\n  \"kind\": \"\",\n  \"phoneNumber\": \"\",\n  \"priority\": 0,\n  \"sharingFeatures\": [],\n  \"source\": \"\",\n  \"speakableName\": \"\",\n  \"type\": \"\"\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}}/contacts/:id";

    let payload = json!({
        "acceptCommands": (json!({"type": ""})),
        "acceptTypes": (),
        "displayName": "",
        "id": "",
        "imageUrls": (),
        "kind": "",
        "phoneNumber": "",
        "priority": 0,
        "sharingFeatures": (),
        "source": "",
        "speakableName": "",
        "type": ""
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/contacts/:id \
  --header 'content-type: application/json' \
  --data '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}'

echo '{
  "acceptCommands": [
    {
      "type": ""
    }
  ],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
}' |  \
  http PUT {{baseUrl}}/contacts/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "acceptCommands": [\n    {\n      "type": ""\n    }\n  ],\n  "acceptTypes": [],\n  "displayName": "",\n  "id": "",\n  "imageUrls": [],\n  "kind": "",\n  "phoneNumber": "",\n  "priority": 0,\n  "sharingFeatures": [],\n  "source": "",\n  "speakableName": "",\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/contacts/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "acceptCommands": [["type": ""]],
  "acceptTypes": [],
  "displayName": "",
  "id": "",
  "imageUrls": [],
  "kind": "",
  "phoneNumber": "",
  "priority": 0,
  "sharingFeatures": [],
  "source": "",
  "speakableName": "",
  "type": ""
] as [String : Any]

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

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

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

dataTask.resume()

GET mirror.locations.get

{{baseUrl}}/locations/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/locations/:id")

require "http/client"

url = "{{baseUrl}}/locations/:id"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/locations/:id"

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

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

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

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

}

GET /baseUrl/locations/:id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/locations/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/locations/:id")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/locations/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/locations/:id'};

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

const url = '{{baseUrl}}/locations/:id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/locations/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/locations/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/locations/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/locations/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/locations/:id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/locations/:id'};

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

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

const url = '{{baseUrl}}/locations/:id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/locations/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/locations/:id" in

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

 "{{baseUrl}}/locations/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/locations/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/locations/:id');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/locations/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/locations/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/locations/:id")

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

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

import requests

url = "{{baseUrl}}/locations/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/locations/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/locations/:id")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/locations/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/locations/:id

http GET {{baseUrl}}/locations/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/locations/:id

import Foundation

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

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

dataTask.resume()

GET mirror.locations.list

{{baseUrl}}/locations

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/locations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/locations")

require "http/client"

url = "{{baseUrl}}/locations"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/locations"

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

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

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

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

}

GET /baseUrl/locations HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/locations")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/locations")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/locations');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/locations';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/locations',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/locations")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/locations',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/locations');

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

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

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

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

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

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

const url = '{{baseUrl}}/locations';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/locations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/locations" in

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

 "{{baseUrl}}/locations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/locations');

echo $response->getBody();

setUrl('{{baseUrl}}/locations');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/locations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/locations' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/locations")

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

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

import requests

url = "{{baseUrl}}/locations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/locations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/locations")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/locations') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/locations

http GET {{baseUrl}}/locations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/locations

import Foundation

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

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

dataTask.resume()

GET mirror.settings.get

{{baseUrl}}/settings/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/settings/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/settings/:id")

require "http/client"

url = "{{baseUrl}}/settings/:id"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/settings/:id"

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

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

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

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

}

GET /baseUrl/settings/:id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/settings/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/settings/:id")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/settings/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/settings/:id'};

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

const url = '{{baseUrl}}/settings/:id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/settings/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/settings/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/settings/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/settings/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/settings/:id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/settings/:id'};

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

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

const url = '{{baseUrl}}/settings/:id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/settings/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/settings/:id" in

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

 "{{baseUrl}}/settings/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/settings/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/settings/:id');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/settings/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/settings/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/settings/:id")

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

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

import requests

url = "{{baseUrl}}/settings/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/settings/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/settings/:id")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/settings/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/settings/:id

http GET {{baseUrl}}/settings/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/settings/:id

import Foundation

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

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

dataTask.resume()

DELETE mirror.subscriptions.delete

{{baseUrl}}/subscriptions/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/subscriptions/:id")

require "http/client"

url = "{{baseUrl}}/subscriptions/:id"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/subscriptions/:id"

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

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

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

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

}

DELETE /baseUrl/subscriptions/:id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/subscriptions/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/subscriptions/:id'};

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

const url = '{{baseUrl}}/subscriptions/:id';
const options = {method: 'DELETE'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/subscriptions/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

const options = {method: 'DELETE', url: '{{baseUrl}}/subscriptions/:id'};

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

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

const url = '{{baseUrl}}/subscriptions/:id';
const options = {method: 'DELETE'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/subscriptions/:id" in

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

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

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/subscriptions/:id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/subscriptions/:id")

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

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

import requests

url = "{{baseUrl}}/subscriptions/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/subscriptions/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/subscriptions/:id")

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/subscriptions/:id

http DELETE {{baseUrl}}/subscriptions/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/subscriptions/:id

import Foundation

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

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

dataTask.resume()

POST mirror.subscriptions.insert

{{baseUrl}}/subscriptions

BODY json

{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/subscriptions");

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  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/subscriptions" {:content-type :json
                                                          :form-params {:callbackUrl ""
                                                                        :collection ""
                                                                        :id ""
                                                                        :kind ""
                                                                        :notification {:collection ""
                                                                                       :itemId ""
                                                                                       :operation ""
                                                                                       :userActions [{:payload ""
                                                                                                      :type ""}]
                                                                                       :userToken ""
                                                                                       :verifyToken ""}
                                                                        :operation []
                                                                        :updated ""
                                                                        :userToken ""
                                                                        :verifyToken ""}})

require "http/client"

url = "{{baseUrl}}/subscriptions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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}}/subscriptions"),
    Content = new StringContent("{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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}}/subscriptions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/subscriptions"

	payload := strings.NewReader("{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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/subscriptions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 360

{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/subscriptions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/subscriptions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/subscriptions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/subscriptions")
  .header("content-type", "application/json")
  .body("{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  callbackUrl: '',
  collection: '',
  id: '',
  kind: '',
  notification: {
    collection: '',
    itemId: '',
    operation: '',
    userActions: [
      {
        payload: '',
        type: ''
      }
    ],
    userToken: '',
    verifyToken: ''
  },
  operation: [],
  updated: '',
  userToken: '',
  verifyToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/subscriptions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/subscriptions',
  headers: {'content-type': 'application/json'},
  data: {
    callbackUrl: '',
    collection: '',
    id: '',
    kind: '',
    notification: {
      collection: '',
      itemId: '',
      operation: '',
      userActions: [{payload: '', type: ''}],
      userToken: '',
      verifyToken: ''
    },
    operation: [],
    updated: '',
    userToken: '',
    verifyToken: ''
  }
};

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

const url = '{{baseUrl}}/subscriptions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"callbackUrl":"","collection":"","id":"","kind":"","notification":{"collection":"","itemId":"","operation":"","userActions":[{"payload":"","type":""}],"userToken":"","verifyToken":""},"operation":[],"updated":"","userToken":"","verifyToken":""}'
};

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}}/subscriptions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "callbackUrl": "",\n  "collection": "",\n  "id": "",\n  "kind": "",\n  "notification": {\n    "collection": "",\n    "itemId": "",\n    "operation": "",\n    "userActions": [\n      {\n        "payload": "",\n        "type": ""\n      }\n    ],\n    "userToken": "",\n    "verifyToken": ""\n  },\n  "operation": [],\n  "updated": "",\n  "userToken": "",\n  "verifyToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/subscriptions")
  .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/subscriptions',
  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({
  callbackUrl: '',
  collection: '',
  id: '',
  kind: '',
  notification: {
    collection: '',
    itemId: '',
    operation: '',
    userActions: [{payload: '', type: ''}],
    userToken: '',
    verifyToken: ''
  },
  operation: [],
  updated: '',
  userToken: '',
  verifyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/subscriptions',
  headers: {'content-type': 'application/json'},
  body: {
    callbackUrl: '',
    collection: '',
    id: '',
    kind: '',
    notification: {
      collection: '',
      itemId: '',
      operation: '',
      userActions: [{payload: '', type: ''}],
      userToken: '',
      verifyToken: ''
    },
    operation: [],
    updated: '',
    userToken: '',
    verifyToken: ''
  },
  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}}/subscriptions');

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

req.type('json');
req.send({
  callbackUrl: '',
  collection: '',
  id: '',
  kind: '',
  notification: {
    collection: '',
    itemId: '',
    operation: '',
    userActions: [
      {
        payload: '',
        type: ''
      }
    ],
    userToken: '',
    verifyToken: ''
  },
  operation: [],
  updated: '',
  userToken: '',
  verifyToken: ''
});

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}}/subscriptions',
  headers: {'content-type': 'application/json'},
  data: {
    callbackUrl: '',
    collection: '',
    id: '',
    kind: '',
    notification: {
      collection: '',
      itemId: '',
      operation: '',
      userActions: [{payload: '', type: ''}],
      userToken: '',
      verifyToken: ''
    },
    operation: [],
    updated: '',
    userToken: '',
    verifyToken: ''
  }
};

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

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

const url = '{{baseUrl}}/subscriptions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"callbackUrl":"","collection":"","id":"","kind":"","notification":{"collection":"","itemId":"","operation":"","userActions":[{"payload":"","type":""}],"userToken":"","verifyToken":""},"operation":[],"updated":"","userToken":"","verifyToken":""}'
};

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 = @{ @"callbackUrl": @"",
                              @"collection": @"",
                              @"id": @"",
                              @"kind": @"",
                              @"notification": @{ @"collection": @"", @"itemId": @"", @"operation": @"", @"userActions": @[ @{ @"payload": @"", @"type": @"" } ], @"userToken": @"", @"verifyToken": @"" },
                              @"operation": @[  ],
                              @"updated": @"",
                              @"userToken": @"",
                              @"verifyToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/subscriptions"]
                                                       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}}/subscriptions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}" in

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

 "{{baseUrl}}/subscriptions",
  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([
    'callbackUrl' => '',
    'collection' => '',
    'id' => '',
    'kind' => '',
    'notification' => [
        'collection' => '',
        'itemId' => '',
        'operation' => '',
        'userActions' => [
                [
                                'payload' => '',
                                'type' => ''
                ]
        ],
        'userToken' => '',
        'verifyToken' => ''
    ],
    'operation' => [
        
    ],
    'updated' => '',
    'userToken' => '',
    'verifyToken' => ''
  ]),
  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}}/subscriptions', [
  'body' => '{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/subscriptions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'callbackUrl' => '',
  'collection' => '',
  'id' => '',
  'kind' => '',
  'notification' => [
    'collection' => '',
    'itemId' => '',
    'operation' => '',
    'userActions' => [
        [
                'payload' => '',
                'type' => ''
        ]
    ],
    'userToken' => '',
    'verifyToken' => ''
  ],
  'operation' => [
    
  ],
  'updated' => '',
  'userToken' => '',
  'verifyToken' => ''
]));

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

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

append(json_encode([
  'callbackUrl' => '',
  'collection' => '',
  'id' => '',
  'kind' => '',
  'notification' => [
    'collection' => '',
    'itemId' => '',
    'operation' => '',
    'userActions' => [
        [
                'payload' => '',
                'type' => ''
        ]
    ],
    'userToken' => '',
    'verifyToken' => ''
  ],
  'operation' => [
    
  ],
  'updated' => '',
  'userToken' => '',
  'verifyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/subscriptions');
$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}}/subscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/subscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}'

import http.client

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

payload = "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/subscriptions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/subscriptions"

payload = {
    "callbackUrl": "",
    "collection": "",
    "id": "",
    "kind": "",
    "notification": {
        "collection": "",
        "itemId": "",
        "operation": "",
        "userActions": [
            {
                "payload": "",
                "type": ""
            }
        ],
        "userToken": "",
        "verifyToken": ""
    },
    "operation": [],
    "updated": "",
    "userToken": "",
    "verifyToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/subscriptions"

payload <- "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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}}/subscriptions")

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  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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/subscriptions') do |req|
  req.body = "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "callbackUrl": "",
        "collection": "",
        "id": "",
        "kind": "",
        "notification": json!({
            "collection": "",
            "itemId": "",
            "operation": "",
            "userActions": (
                json!({
                    "payload": "",
                    "type": ""
                })
            ),
            "userToken": "",
            "verifyToken": ""
        }),
        "operation": (),
        "updated": "",
        "userToken": "",
        "verifyToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/subscriptions \
  --header 'content-type: application/json' \
  --data '{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}'

echo '{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}' |  \
  http POST {{baseUrl}}/subscriptions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "callbackUrl": "",\n  "collection": "",\n  "id": "",\n  "kind": "",\n  "notification": {\n    "collection": "",\n    "itemId": "",\n    "operation": "",\n    "userActions": [\n      {\n        "payload": "",\n        "type": ""\n      }\n    ],\n    "userToken": "",\n    "verifyToken": ""\n  },\n  "operation": [],\n  "updated": "",\n  "userToken": "",\n  "verifyToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/subscriptions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": [
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      [
        "payload": "",
        "type": ""
      ]
    ],
    "userToken": "",
    "verifyToken": ""
  ],
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

GET mirror.subscriptions.list

{{baseUrl}}/subscriptions

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/subscriptions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/subscriptions")

require "http/client"

url = "{{baseUrl}}/subscriptions"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/subscriptions"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/subscriptions'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/subscriptions")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/subscriptions');

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}}/subscriptions'};

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

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

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

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

 "{{baseUrl}}/subscriptions",
  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}}/subscriptions');

echo $response->getBody();

setUrl('{{baseUrl}}/subscriptions');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/subscriptions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/subscriptions' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/subscriptions")

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

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

import requests

url = "{{baseUrl}}/subscriptions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/subscriptions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/subscriptions")

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/subscriptions') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/subscriptions

http GET {{baseUrl}}/subscriptions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/subscriptions

import Foundation

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

PUT mirror.subscriptions.update

{{baseUrl}}/subscriptions/:id

QUERY PARAMS

BODY json

{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/subscriptions/:id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/subscriptions/:id" {:content-type :json
                                                             :form-params {:callbackUrl ""
                                                                           :collection ""
                                                                           :id ""
                                                                           :kind ""
                                                                           :notification {:collection ""
                                                                                          :itemId ""
                                                                                          :operation ""
                                                                                          :userActions [{:payload ""
                                                                                                         :type ""}]
                                                                                          :userToken ""
                                                                                          :verifyToken ""}
                                                                           :operation []
                                                                           :updated ""
                                                                           :userToken ""
                                                                           :verifyToken ""}})

require "http/client"

url = "{{baseUrl}}/subscriptions/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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}}/subscriptions/:id"),
    Content = new StringContent("{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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}}/subscriptions/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/subscriptions/:id"

	payload := strings.NewReader("{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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/subscriptions/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 360

{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/subscriptions/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/subscriptions/:id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/subscriptions/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/subscriptions/:id")
  .header("content-type", "application/json")
  .body("{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  callbackUrl: '',
  collection: '',
  id: '',
  kind: '',
  notification: {
    collection: '',
    itemId: '',
    operation: '',
    userActions: [
      {
        payload: '',
        type: ''
      }
    ],
    userToken: '',
    verifyToken: ''
  },
  operation: [],
  updated: '',
  userToken: '',
  verifyToken: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/subscriptions/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/subscriptions/:id',
  headers: {'content-type': 'application/json'},
  data: {
    callbackUrl: '',
    collection: '',
    id: '',
    kind: '',
    notification: {
      collection: '',
      itemId: '',
      operation: '',
      userActions: [{payload: '', type: ''}],
      userToken: '',
      verifyToken: ''
    },
    operation: [],
    updated: '',
    userToken: '',
    verifyToken: ''
  }
};

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

const url = '{{baseUrl}}/subscriptions/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"callbackUrl":"","collection":"","id":"","kind":"","notification":{"collection":"","itemId":"","operation":"","userActions":[{"payload":"","type":""}],"userToken":"","verifyToken":""},"operation":[],"updated":"","userToken":"","verifyToken":""}'
};

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}}/subscriptions/:id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "callbackUrl": "",\n  "collection": "",\n  "id": "",\n  "kind": "",\n  "notification": {\n    "collection": "",\n    "itemId": "",\n    "operation": "",\n    "userActions": [\n      {\n        "payload": "",\n        "type": ""\n      }\n    ],\n    "userToken": "",\n    "verifyToken": ""\n  },\n  "operation": [],\n  "updated": "",\n  "userToken": "",\n  "verifyToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/subscriptions/:id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/subscriptions/:id',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  callbackUrl: '',
  collection: '',
  id: '',
  kind: '',
  notification: {
    collection: '',
    itemId: '',
    operation: '',
    userActions: [{payload: '', type: ''}],
    userToken: '',
    verifyToken: ''
  },
  operation: [],
  updated: '',
  userToken: '',
  verifyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/subscriptions/:id',
  headers: {'content-type': 'application/json'},
  body: {
    callbackUrl: '',
    collection: '',
    id: '',
    kind: '',
    notification: {
      collection: '',
      itemId: '',
      operation: '',
      userActions: [{payload: '', type: ''}],
      userToken: '',
      verifyToken: ''
    },
    operation: [],
    updated: '',
    userToken: '',
    verifyToken: ''
  },
  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}}/subscriptions/:id');

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

req.type('json');
req.send({
  callbackUrl: '',
  collection: '',
  id: '',
  kind: '',
  notification: {
    collection: '',
    itemId: '',
    operation: '',
    userActions: [
      {
        payload: '',
        type: ''
      }
    ],
    userToken: '',
    verifyToken: ''
  },
  operation: [],
  updated: '',
  userToken: '',
  verifyToken: ''
});

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}}/subscriptions/:id',
  headers: {'content-type': 'application/json'},
  data: {
    callbackUrl: '',
    collection: '',
    id: '',
    kind: '',
    notification: {
      collection: '',
      itemId: '',
      operation: '',
      userActions: [{payload: '', type: ''}],
      userToken: '',
      verifyToken: ''
    },
    operation: [],
    updated: '',
    userToken: '',
    verifyToken: ''
  }
};

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

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

const url = '{{baseUrl}}/subscriptions/:id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"callbackUrl":"","collection":"","id":"","kind":"","notification":{"collection":"","itemId":"","operation":"","userActions":[{"payload":"","type":""}],"userToken":"","verifyToken":""},"operation":[],"updated":"","userToken":"","verifyToken":""}'
};

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 = @{ @"callbackUrl": @"",
                              @"collection": @"",
                              @"id": @"",
                              @"kind": @"",
                              @"notification": @{ @"collection": @"", @"itemId": @"", @"operation": @"", @"userActions": @[ @{ @"payload": @"", @"type": @"" } ], @"userToken": @"", @"verifyToken": @"" },
                              @"operation": @[  ],
                              @"updated": @"",
                              @"userToken": @"",
                              @"verifyToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/subscriptions/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/subscriptions/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}" in

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

 "{{baseUrl}}/subscriptions/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'callbackUrl' => '',
    'collection' => '',
    'id' => '',
    'kind' => '',
    'notification' => [
        'collection' => '',
        'itemId' => '',
        'operation' => '',
        'userActions' => [
                [
                                'payload' => '',
                                'type' => ''
                ]
        ],
        'userToken' => '',
        'verifyToken' => ''
    ],
    'operation' => [
        
    ],
    'updated' => '',
    'userToken' => '',
    'verifyToken' => ''
  ]),
  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}}/subscriptions/:id', [
  'body' => '{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/subscriptions/:id');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'callbackUrl' => '',
  'collection' => '',
  'id' => '',
  'kind' => '',
  'notification' => [
    'collection' => '',
    'itemId' => '',
    'operation' => '',
    'userActions' => [
        [
                'payload' => '',
                'type' => ''
        ]
    ],
    'userToken' => '',
    'verifyToken' => ''
  ],
  'operation' => [
    
  ],
  'updated' => '',
  'userToken' => '',
  'verifyToken' => ''
]));

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

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

append(json_encode([
  'callbackUrl' => '',
  'collection' => '',
  'id' => '',
  'kind' => '',
  'notification' => [
    'collection' => '',
    'itemId' => '',
    'operation' => '',
    'userActions' => [
        [
                'payload' => '',
                'type' => ''
        ]
    ],
    'userToken' => '',
    'verifyToken' => ''
  ],
  'operation' => [
    
  ],
  'updated' => '',
  'userToken' => '',
  'verifyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/subscriptions/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/subscriptions/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/subscriptions/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}'

import http.client

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

payload = "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/subscriptions/:id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/subscriptions/:id"

payload = {
    "callbackUrl": "",
    "collection": "",
    "id": "",
    "kind": "",
    "notification": {
        "collection": "",
        "itemId": "",
        "operation": "",
        "userActions": [
            {
                "payload": "",
                "type": ""
            }
        ],
        "userToken": "",
        "verifyToken": ""
    },
    "operation": [],
    "updated": "",
    "userToken": "",
    "verifyToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/subscriptions/:id"

payload <- "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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}}/subscriptions/:id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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/subscriptions/:id') do |req|
  req.body = "{\n  \"callbackUrl\": \"\",\n  \"collection\": \"\",\n  \"id\": \"\",\n  \"kind\": \"\",\n  \"notification\": {\n    \"collection\": \"\",\n    \"itemId\": \"\",\n    \"operation\": \"\",\n    \"userActions\": [\n      {\n        \"payload\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"userToken\": \"\",\n    \"verifyToken\": \"\"\n  },\n  \"operation\": [],\n  \"updated\": \"\",\n  \"userToken\": \"\",\n  \"verifyToken\": \"\"\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}}/subscriptions/:id";

    let payload = json!({
        "callbackUrl": "",
        "collection": "",
        "id": "",
        "kind": "",
        "notification": json!({
            "collection": "",
            "itemId": "",
            "operation": "",
            "userActions": (
                json!({
                    "payload": "",
                    "type": ""
                })
            ),
            "userToken": "",
            "verifyToken": ""
        }),
        "operation": (),
        "updated": "",
        "userToken": "",
        "verifyToken": ""
    });

    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);
}

curl --request PUT \
  --url {{baseUrl}}/subscriptions/:id \
  --header 'content-type: application/json' \
  --data '{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}'

echo '{
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": {
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      {
        "payload": "",
        "type": ""
      }
    ],
    "userToken": "",
    "verifyToken": ""
  },
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
}' |  \
  http PUT {{baseUrl}}/subscriptions/:id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "callbackUrl": "",\n  "collection": "",\n  "id": "",\n  "kind": "",\n  "notification": {\n    "collection": "",\n    "itemId": "",\n    "operation": "",\n    "userActions": [\n      {\n        "payload": "",\n        "type": ""\n      }\n    ],\n    "userToken": "",\n    "verifyToken": ""\n  },\n  "operation": [],\n  "updated": "",\n  "userToken": "",\n  "verifyToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/subscriptions/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "callbackUrl": "",
  "collection": "",
  "id": "",
  "kind": "",
  "notification": [
    "collection": "",
    "itemId": "",
    "operation": "",
    "userActions": [
      [
        "payload": "",
        "type": ""
      ]
    ],
    "userToken": "",
    "verifyToken": ""
  ],
  "operation": [],
  "updated": "",
  "userToken": "",
  "verifyToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

DELETE mirror.timeline.attachments.delete

{{baseUrl}}/timeline/:itemId/attachments/:attachmentId

QUERY PARAMS

itemId

attachmentId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")

require "http/client"

url = "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId"

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

var client = new RestClient("{{baseUrl}}/timeline/:itemId/attachments/:attachmentId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId"

	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/timeline/:itemId/attachments/:attachmentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/timeline/:itemId/attachments/:attachmentId"))
    .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}}/timeline/:itemId/attachments/:attachmentId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")
  .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}}/timeline/:itemId/attachments/:attachmentId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId'
};

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

const url = '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId';
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}}/timeline/:itemId/attachments/:attachmentId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/timeline/:itemId/attachments/:attachmentId',
  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}}/timeline/:itemId/attachments/:attachmentId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId');

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}}/timeline/:itemId/attachments/:attachmentId'
};

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

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

const url = '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId';
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}}/timeline/:itemId/attachments/:attachmentId"]
                                                       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}}/timeline/:itemId/attachments/:attachmentId" in

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

 "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId",
  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}}/timeline/:itemId/attachments/:attachmentId');

echo $response->getBody();

setUrl('{{baseUrl}}/timeline/:itemId/attachments/:attachmentId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/timeline/:itemId/attachments/:attachmentId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/timeline/:itemId/attachments/:attachmentId")

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

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

import requests

url = "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")

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/timeline/:itemId/attachments/:attachmentId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId";

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/timeline/:itemId/attachments/:attachmentId

http DELETE {{baseUrl}}/timeline/:itemId/attachments/:attachmentId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/timeline/:itemId/attachments/:attachmentId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")! 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()

GET mirror.timeline.attachments.get

{{baseUrl}}/timeline/:itemId/attachments/:attachmentId

QUERY PARAMS

itemId

attachmentId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")

require "http/client"

url = "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId"

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

var client = new RestClient("{{baseUrl}}/timeline/:itemId/attachments/:attachmentId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId"

	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/timeline/:itemId/attachments/:attachmentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/timeline/:itemId/attachments/:attachmentId"))
    .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}}/timeline/:itemId/attachments/:attachmentId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")
  .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}}/timeline/:itemId/attachments/:attachmentId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId'
};

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

const url = '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId';
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}}/timeline/:itemId/attachments/:attachmentId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId');

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}}/timeline/:itemId/attachments/:attachmentId'
};

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

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

const url = '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId';
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}}/timeline/:itemId/attachments/:attachmentId"]
                                                       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}}/timeline/:itemId/attachments/:attachmentId" in

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

 "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId",
  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}}/timeline/:itemId/attachments/:attachmentId');

echo $response->getBody();

setUrl('{{baseUrl}}/timeline/:itemId/attachments/:attachmentId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/timeline/:itemId/attachments/:attachmentId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeline/:itemId/attachments/:attachmentId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/timeline/:itemId/attachments/:attachmentId")

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

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

import requests

url = "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")

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/timeline/:itemId/attachments/:attachmentId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/timeline/:itemId/attachments/:attachmentId

http GET {{baseUrl}}/timeline/:itemId/attachments/:attachmentId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/timeline/:itemId/attachments/:attachmentId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timeline/:itemId/attachments/:attachmentId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

POST mirror.timeline.attachments.insert

{{baseUrl}}/timeline/:itemId/attachments

QUERY PARAMS

itemId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timeline/:itemId/attachments");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/timeline/:itemId/attachments")

require "http/client"

url = "{{baseUrl}}/timeline/:itemId/attachments"

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

var client = new RestClient("{{baseUrl}}/timeline/:itemId/attachments");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/timeline/:itemId/attachments"

	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/timeline/:itemId/attachments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/timeline/:itemId/attachments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/timeline/:itemId/attachments"))
    .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}}/timeline/:itemId/attachments")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/timeline/:itemId/attachments")
  .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}}/timeline/:itemId/attachments');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/timeline/:itemId/attachments'
};

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

const url = '{{baseUrl}}/timeline/:itemId/attachments';
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}}/timeline/:itemId/attachments',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/timeline/:itemId/attachments")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/timeline/:itemId/attachments',
  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}}/timeline/:itemId/attachments'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/timeline/:itemId/attachments');

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}}/timeline/:itemId/attachments'
};

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

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

const url = '{{baseUrl}}/timeline/:itemId/attachments';
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}}/timeline/:itemId/attachments"]
                                                       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}}/timeline/:itemId/attachments" in

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

 "{{baseUrl}}/timeline/:itemId/attachments",
  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}}/timeline/:itemId/attachments');

echo $response->getBody();

setUrl('{{baseUrl}}/timeline/:itemId/attachments');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/timeline/:itemId/attachments');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/timeline/:itemId/attachments' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeline/:itemId/attachments' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/timeline/:itemId/attachments")

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

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

import requests

url = "{{baseUrl}}/timeline/:itemId/attachments"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeline/:itemId/attachments"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeline/:itemId/attachments")

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/timeline/:itemId/attachments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/timeline/:itemId/attachments";

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/timeline/:itemId/attachments

http POST {{baseUrl}}/timeline/:itemId/attachments

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/timeline/:itemId/attachments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timeline/:itemId/attachments")! 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()

GET mirror.timeline.attachments.list

{{baseUrl}}/timeline/:itemId/attachments

QUERY PARAMS

itemId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timeline/:itemId/attachments");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/timeline/:itemId/attachments")

require "http/client"

url = "{{baseUrl}}/timeline/:itemId/attachments"

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

var client = new RestClient("{{baseUrl}}/timeline/:itemId/attachments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/timeline/:itemId/attachments"

	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/timeline/:itemId/attachments HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/timeline/:itemId/attachments'};

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

const url = '{{baseUrl}}/timeline/:itemId/attachments';
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}}/timeline/:itemId/attachments',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/timeline/:itemId/attachments")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/timeline/:itemId/attachments');

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}}/timeline/:itemId/attachments'};

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

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

const url = '{{baseUrl}}/timeline/:itemId/attachments';
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}}/timeline/:itemId/attachments"]
                                                       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}}/timeline/:itemId/attachments" in

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

 "{{baseUrl}}/timeline/:itemId/attachments",
  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}}/timeline/:itemId/attachments');

echo $response->getBody();

setUrl('{{baseUrl}}/timeline/:itemId/attachments');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/timeline/:itemId/attachments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/timeline/:itemId/attachments' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeline/:itemId/attachments' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/timeline/:itemId/attachments")

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

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

import requests

url = "{{baseUrl}}/timeline/:itemId/attachments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeline/:itemId/attachments"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeline/:itemId/attachments")

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/timeline/:itemId/attachments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/timeline/:itemId/attachments";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/timeline/:itemId/attachments

http GET {{baseUrl}}/timeline/:itemId/attachments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/timeline/:itemId/attachments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timeline/:itemId/attachments")! 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()

DELETE mirror.timeline.delete

{{baseUrl}}/timeline/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/timeline/:id")

require "http/client"

url = "{{baseUrl}}/timeline/:id"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/timeline/:id"

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

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

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

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

}

DELETE /baseUrl/timeline/:id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/timeline/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/timeline/:id'};

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

const url = '{{baseUrl}}/timeline/:id';
const options = {method: 'DELETE'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/timeline/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

const options = {method: 'DELETE', url: '{{baseUrl}}/timeline/:id'};

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

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

const url = '{{baseUrl}}/timeline/:id';
const options = {method: 'DELETE'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/timeline/:id" in

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

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

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/timeline/:id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/timeline/:id")

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

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

import requests

url = "{{baseUrl}}/timeline/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeline/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeline/:id")

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/timeline/:id

http DELETE {{baseUrl}}/timeline/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/timeline/:id

import Foundation

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

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

dataTask.resume()

GET mirror.timeline.get

{{baseUrl}}/timeline/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timeline/:id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/timeline/:id")

require "http/client"

url = "{{baseUrl}}/timeline/:id"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/timeline/:id"

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

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

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

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

}

GET /baseUrl/timeline/:id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/timeline/:id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/timeline/:id")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/timeline/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/timeline/:id'};

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

const url = '{{baseUrl}}/timeline/:id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/timeline/:id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/timeline/:id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/timeline/:id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/timeline/:id'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/timeline/:id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/timeline/:id'};

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

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

const url = '{{baseUrl}}/timeline/:id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/timeline/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/timeline/:id" in

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

 "{{baseUrl}}/timeline/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/timeline/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/timeline/:id');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/timeline/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeline/:id' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/timeline/:id")

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

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

import requests

url = "{{baseUrl}}/timeline/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeline/:id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeline/:id")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/timeline/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/timeline/:id

http GET {{baseUrl}}/timeline/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/timeline/:id

import Foundation

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

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

dataTask.resume()

POST mirror.timeline.insert

{{baseUrl}}/timeline

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timeline");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/timeline")

require "http/client"

url = "{{baseUrl}}/timeline"

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

var client = new RestClient("{{baseUrl}}/timeline");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/timeline"

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/timeline"))
    .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}}/timeline")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/timeline")
  .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}}/timeline');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/timeline'};

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

const url = '{{baseUrl}}/timeline';
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}}/timeline',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/timeline")
  .post(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/timeline');

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}}/timeline'};

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

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

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

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

 "{{baseUrl}}/timeline",
  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}}/timeline');

echo $response->getBody();

setUrl('{{baseUrl}}/timeline');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/timeline');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/timeline' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeline' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/timeline")

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

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

import requests

url = "{{baseUrl}}/timeline"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeline"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeline")

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/timeline') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/timeline

http POST {{baseUrl}}/timeline

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/timeline

import Foundation

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

GET mirror.timeline.list

{{baseUrl}}/timeline

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timeline");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/timeline")

require "http/client"

url = "{{baseUrl}}/timeline"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/timeline"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/timeline'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/timeline")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/timeline');

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}}/timeline'};

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

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

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

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

 "{{baseUrl}}/timeline",
  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}}/timeline');

echo $response->getBody();

setUrl('{{baseUrl}}/timeline');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/timeline');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/timeline' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeline' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/timeline")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/timeline"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeline"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeline")

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/timeline') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/timeline";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/timeline

http GET {{baseUrl}}/timeline

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/timeline

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timeline")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH mirror.timeline.patch

{{baseUrl}}/timeline/:id

QUERY PARAMS

BODY json

{
  "attachments": [
    {
      "contentType": "",
      "contentUrl": "",
      "id": "",
      "isProcessingContent": false
    }
  ],
  "bundleId": "",
  "canonicalUrl": "",
  "created": "",
  "creator": {
    "acceptCommands": [
      {
        "type": ""
      }
    ],
    "acceptTypes": [],
    "displayName": "",
    "id": "",
    "imageUrls": [],
    "kind": "",
    "phoneNumber": "",
    "priority": 0,
    "sharingFeatures": [],
    "source": "",
    "speakableName": "",
    "type": ""
  },
  "displayTime": "",
  "etag": "",
  "html": "",
  "id": "",
  "inReplyTo": "",
  "isBundleCover": false,
  "isDeleted": false,
  "isPinned": false,
  "kind": "",
  "location": {
    "accuracy": "",
    "address": "",
    "displayName": "",
    "id": "",
    "kind": "",
    "latitude": "",
    "longitude": "",
    "timestamp": ""
  },
  "menuItems": [
    {
      "action": "",
      "contextual_command": "",
      "id": "",
      "payload": "",
      "removeWhenSelected": false,
      "values": [
        {
          "displayName": "",
          "iconUrl": "",
          "state": ""
        }
      ]
    }
  ],
  "notification": {
    "deliveryTime": "",
    "level": ""
  },
  "pinScore": 0,
  "recipients": [
    {}
  ],
  "selfLink": "",
  "sourceItemId": "",
  "speakableText": "",
  "speakableType": "",
  "text": "",
  "title": "",
  "updated": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timeline/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/timeline/:id" {:content-type :json
                                                          :form-params {:attachments [{:contentType ""
                                                                                       :contentUrl ""
                                                                                       :id ""
                                                                                       :isProcessingContent false}]
                                                                        :bundleId ""
                                                                        :canonicalUrl ""
                                                                        :created ""
                                                                        :creator {:acceptCommands [{:type ""}]
                                                                                  :acceptTypes []
                                                                                  :displayName ""
                                                                                  :id ""
                                                                                  :imageUrls []
                                                                                  :kind ""
                                                                                  :phoneNumber ""
                                                                                  :priority 0
                                                                                  :sharingFeatures []
                                                                                  :source ""
                                                                                  :speakableName ""
                                                                                  :type ""}
                                                                        :displayTime ""
                                                                        :etag ""
                                                                        :html ""
                                                                        :id ""
                                                                        :inReplyTo ""
                                                                        :isBundleCover false
                                                                        :isDeleted false
                                                                        :isPinned false
                                                                        :kind ""
                                                                        :location {:accuracy ""
                                                                                   :address ""
                                                                                   :displayName ""
                                                                                   :id ""
                                                                                   :kind ""
                                                                                   :latitude ""
                                                                                   :longitude ""
                                                                                   :timestamp ""}
                                                                        :menuItems [{:action ""
                                                                                     :contextual_command ""
                                                                                     :id ""
                                                                                     :payload ""
                                                                                     :removeWhenSelected false
                                                                                     :values [{:displayName ""
                                                                                               :iconUrl ""
                                                                                               :state ""}]}]
                                                                        :notification {:deliveryTime ""
                                                                                       :level ""}
                                                                        :pinScore 0
                                                                        :recipients [{}]
                                                                        :selfLink ""
                                                                        :sourceItemId ""
                                                                        :speakableText ""
                                                                        :speakableType ""
                                                                        :text ""
                                                                        :title ""
                                                                        :updated ""}})

require "http/client"

url = "{{baseUrl}}/timeline/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\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}}/timeline/:id"),
    Content = new StringContent("{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\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}}/timeline/:id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/timeline/:id"

	payload := strings.NewReader("{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\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/timeline/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1366

{
  "attachments": [
    {
      "contentType": "",
      "contentUrl": "",
      "id": "",
      "isProcessingContent": false
    }
  ],
  "bundleId": "",
  "canonicalUrl": "",
  "created": "",
  "creator": {
    "acceptCommands": [
      {
        "type": ""
      }
    ],
    "acceptTypes": [],
    "displayName": "",
    "id": "",
    "imageUrls": [],
    "kind": "",
    "phoneNumber": "",
    "priority": 0,
    "sharingFeatures": [],
    "source": "",
    "speakableName": "",
    "type": ""
  },
  "displayTime": "",
  "etag": "",
  "html": "",
  "id": "",
  "inReplyTo": "",
  "isBundleCover": false,
  "isDeleted": false,
  "isPinned": false,
  "kind": "",
  "location": {
    "accuracy": "",
    "address": "",
    "displayName": "",
    "id": "",
    "kind": "",
    "latitude": "",
    "longitude": "",
    "timestamp": ""
  },
  "menuItems": [
    {
      "action": "",
      "contextual_command": "",
      "id": "",
      "payload": "",
      "removeWhenSelected": false,
      "values": [
        {
          "displayName": "",
          "iconUrl": "",
          "state": ""
        }
      ]
    }
  ],
  "notification": {
    "deliveryTime": "",
    "level": ""
  },
  "pinScore": 0,
  "recipients": [
    {}
  ],
  "selfLink": "",
  "sourceItemId": "",
  "speakableText": "",
  "speakableType": "",
  "text": "",
  "title": "",
  "updated": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/timeline/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/timeline/:id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\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  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/timeline/:id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/timeline/:id")
  .header("content-type", "application/json")
  .body("{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  attachments: [
    {
      contentType: '',
      contentUrl: '',
      id: '',
      isProcessingContent: false
    }
  ],
  bundleId: '',
  canonicalUrl: '',
  created: '',
  creator: {
    acceptCommands: [
      {
        type: ''
      }
    ],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  },
  displayTime: '',
  etag: '',
  html: '',
  id: '',
  inReplyTo: '',
  isBundleCover: false,
  isDeleted: false,
  isPinned: false,
  kind: '',
  location: {
    accuracy: '',
    address: '',
    displayName: '',
    id: '',
    kind: '',
    latitude: '',
    longitude: '',
    timestamp: ''
  },
  menuItems: [
    {
      action: '',
      contextual_command: '',
      id: '',
      payload: '',
      removeWhenSelected: false,
      values: [
        {
          displayName: '',
          iconUrl: '',
          state: ''
        }
      ]
    }
  ],
  notification: {
    deliveryTime: '',
    level: ''
  },
  pinScore: 0,
  recipients: [
    {}
  ],
  selfLink: '',
  sourceItemId: '',
  speakableText: '',
  speakableType: '',
  text: '',
  title: '',
  updated: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/timeline/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/timeline/:id',
  headers: {'content-type': 'application/json'},
  data: {
    attachments: [{contentType: '', contentUrl: '', id: '', isProcessingContent: false}],
    bundleId: '',
    canonicalUrl: '',
    created: '',
    creator: {
      acceptCommands: [{type: ''}],
      acceptTypes: [],
      displayName: '',
      id: '',
      imageUrls: [],
      kind: '',
      phoneNumber: '',
      priority: 0,
      sharingFeatures: [],
      source: '',
      speakableName: '',
      type: ''
    },
    displayTime: '',
    etag: '',
    html: '',
    id: '',
    inReplyTo: '',
    isBundleCover: false,
    isDeleted: false,
    isPinned: false,
    kind: '',
    location: {
      accuracy: '',
      address: '',
      displayName: '',
      id: '',
      kind: '',
      latitude: '',
      longitude: '',
      timestamp: ''
    },
    menuItems: [
      {
        action: '',
        contextual_command: '',
        id: '',
        payload: '',
        removeWhenSelected: false,
        values: [{displayName: '', iconUrl: '', state: ''}]
      }
    ],
    notification: {deliveryTime: '', level: ''},
    pinScore: 0,
    recipients: [{}],
    selfLink: '',
    sourceItemId: '',
    speakableText: '',
    speakableType: '',
    text: '',
    title: '',
    updated: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/timeline/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"attachments":[{"contentType":"","contentUrl":"","id":"","isProcessingContent":false}],"bundleId":"","canonicalUrl":"","created":"","creator":{"acceptCommands":[{"type":""}],"acceptTypes":[],"displayName":"","id":"","imageUrls":[],"kind":"","phoneNumber":"","priority":0,"sharingFeatures":[],"source":"","speakableName":"","type":""},"displayTime":"","etag":"","html":"","id":"","inReplyTo":"","isBundleCover":false,"isDeleted":false,"isPinned":false,"kind":"","location":{"accuracy":"","address":"","displayName":"","id":"","kind":"","latitude":"","longitude":"","timestamp":""},"menuItems":[{"action":"","contextual_command":"","id":"","payload":"","removeWhenSelected":false,"values":[{"displayName":"","iconUrl":"","state":""}]}],"notification":{"deliveryTime":"","level":""},"pinScore":0,"recipients":[{}],"selfLink":"","sourceItemId":"","speakableText":"","speakableType":"","text":"","title":"","updated":""}'
};

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}}/timeline/:id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attachments": [\n    {\n      "contentType": "",\n      "contentUrl": "",\n      "id": "",\n      "isProcessingContent": false\n    }\n  ],\n  "bundleId": "",\n  "canonicalUrl": "",\n  "created": "",\n  "creator": {\n    "acceptCommands": [\n      {\n        "type": ""\n      }\n    ],\n    "acceptTypes": [],\n    "displayName": "",\n    "id": "",\n    "imageUrls": [],\n    "kind": "",\n    "phoneNumber": "",\n    "priority": 0,\n    "sharingFeatures": [],\n    "source": "",\n    "speakableName": "",\n    "type": ""\n  },\n  "displayTime": "",\n  "etag": "",\n  "html": "",\n  "id": "",\n  "inReplyTo": "",\n  "isBundleCover": false,\n  "isDeleted": false,\n  "isPinned": false,\n  "kind": "",\n  "location": {\n    "accuracy": "",\n    "address": "",\n    "displayName": "",\n    "id": "",\n    "kind": "",\n    "latitude": "",\n    "longitude": "",\n    "timestamp": ""\n  },\n  "menuItems": [\n    {\n      "action": "",\n      "contextual_command": "",\n      "id": "",\n      "payload": "",\n      "removeWhenSelected": false,\n      "values": [\n        {\n          "displayName": "",\n          "iconUrl": "",\n          "state": ""\n        }\n      ]\n    }\n  ],\n  "notification": {\n    "deliveryTime": "",\n    "level": ""\n  },\n  "pinScore": 0,\n  "recipients": [\n    {}\n  ],\n  "selfLink": "",\n  "sourceItemId": "",\n  "speakableText": "",\n  "speakableType": "",\n  "text": "",\n  "title": "",\n  "updated": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/timeline/:id")
  .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/timeline/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  attachments: [{contentType: '', contentUrl: '', id: '', isProcessingContent: false}],
  bundleId: '',
  canonicalUrl: '',
  created: '',
  creator: {
    acceptCommands: [{type: ''}],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  },
  displayTime: '',
  etag: '',
  html: '',
  id: '',
  inReplyTo: '',
  isBundleCover: false,
  isDeleted: false,
  isPinned: false,
  kind: '',
  location: {
    accuracy: '',
    address: '',
    displayName: '',
    id: '',
    kind: '',
    latitude: '',
    longitude: '',
    timestamp: ''
  },
  menuItems: [
    {
      action: '',
      contextual_command: '',
      id: '',
      payload: '',
      removeWhenSelected: false,
      values: [{displayName: '', iconUrl: '', state: ''}]
    }
  ],
  notification: {deliveryTime: '', level: ''},
  pinScore: 0,
  recipients: [{}],
  selfLink: '',
  sourceItemId: '',
  speakableText: '',
  speakableType: '',
  text: '',
  title: '',
  updated: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/timeline/:id',
  headers: {'content-type': 'application/json'},
  body: {
    attachments: [{contentType: '', contentUrl: '', id: '', isProcessingContent: false}],
    bundleId: '',
    canonicalUrl: '',
    created: '',
    creator: {
      acceptCommands: [{type: ''}],
      acceptTypes: [],
      displayName: '',
      id: '',
      imageUrls: [],
      kind: '',
      phoneNumber: '',
      priority: 0,
      sharingFeatures: [],
      source: '',
      speakableName: '',
      type: ''
    },
    displayTime: '',
    etag: '',
    html: '',
    id: '',
    inReplyTo: '',
    isBundleCover: false,
    isDeleted: false,
    isPinned: false,
    kind: '',
    location: {
      accuracy: '',
      address: '',
      displayName: '',
      id: '',
      kind: '',
      latitude: '',
      longitude: '',
      timestamp: ''
    },
    menuItems: [
      {
        action: '',
        contextual_command: '',
        id: '',
        payload: '',
        removeWhenSelected: false,
        values: [{displayName: '', iconUrl: '', state: ''}]
      }
    ],
    notification: {deliveryTime: '', level: ''},
    pinScore: 0,
    recipients: [{}],
    selfLink: '',
    sourceItemId: '',
    speakableText: '',
    speakableType: '',
    text: '',
    title: '',
    updated: ''
  },
  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}}/timeline/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  attachments: [
    {
      contentType: '',
      contentUrl: '',
      id: '',
      isProcessingContent: false
    }
  ],
  bundleId: '',
  canonicalUrl: '',
  created: '',
  creator: {
    acceptCommands: [
      {
        type: ''
      }
    ],
    acceptTypes: [],
    displayName: '',
    id: '',
    imageUrls: [],
    kind: '',
    phoneNumber: '',
    priority: 0,
    sharingFeatures: [],
    source: '',
    speakableName: '',
    type: ''
  },
  displayTime: '',
  etag: '',
  html: '',
  id: '',
  inReplyTo: '',
  isBundleCover: false,
  isDeleted: false,
  isPinned: false,
  kind: '',
  location: {
    accuracy: '',
    address: '',
    displayName: '',
    id: '',
    kind: '',
    latitude: '',
    longitude: '',
    timestamp: ''
  },
  menuItems: [
    {
      action: '',
      contextual_command: '',
      id: '',
      payload: '',
      removeWhenSelected: false,
      values: [
        {
          displayName: '',
          iconUrl: '',
          state: ''
        }
      ]
    }
  ],
  notification: {
    deliveryTime: '',
    level: ''
  },
  pinScore: 0,
  recipients: [
    {}
  ],
  selfLink: '',
  sourceItemId: '',
  speakableText: '',
  speakableType: '',
  text: '',
  title: '',
  updated: ''
});

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}}/timeline/:id',
  headers: {'content-type': 'application/json'},
  data: {
    attachments: [{contentType: '', contentUrl: '', id: '', isProcessingContent: false}],
    bundleId: '',
    canonicalUrl: '',
    created: '',
    creator: {
      acceptCommands: [{type: ''}],
      acceptTypes: [],
      displayName: '',
      id: '',
      imageUrls: [],
      kind: '',
      phoneNumber: '',
      priority: 0,
      sharingFeatures: [],
      source: '',
      speakableName: '',
      type: ''
    },
    displayTime: '',
    etag: '',
    html: '',
    id: '',
    inReplyTo: '',
    isBundleCover: false,
    isDeleted: false,
    isPinned: false,
    kind: '',
    location: {
      accuracy: '',
      address: '',
      displayName: '',
      id: '',
      kind: '',
      latitude: '',
      longitude: '',
      timestamp: ''
    },
    menuItems: [
      {
        action: '',
        contextual_command: '',
        id: '',
        payload: '',
        removeWhenSelected: false,
        values: [{displayName: '', iconUrl: '', state: ''}]
      }
    ],
    notification: {deliveryTime: '', level: ''},
    pinScore: 0,
    recipients: [{}],
    selfLink: '',
    sourceItemId: '',
    speakableText: '',
    speakableType: '',
    text: '',
    title: '',
    updated: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/timeline/:id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"attachments":[{"contentType":"","contentUrl":"","id":"","isProcessingContent":false}],"bundleId":"","canonicalUrl":"","created":"","creator":{"acceptCommands":[{"type":""}],"acceptTypes":[],"displayName":"","id":"","imageUrls":[],"kind":"","phoneNumber":"","priority":0,"sharingFeatures":[],"source":"","speakableName":"","type":""},"displayTime":"","etag":"","html":"","id":"","inReplyTo":"","isBundleCover":false,"isDeleted":false,"isPinned":false,"kind":"","location":{"accuracy":"","address":"","displayName":"","id":"","kind":"","latitude":"","longitude":"","timestamp":""},"menuItems":[{"action":"","contextual_command":"","id":"","payload":"","removeWhenSelected":false,"values":[{"displayName":"","iconUrl":"","state":""}]}],"notification":{"deliveryTime":"","level":""},"pinScore":0,"recipients":[{}],"selfLink":"","sourceItemId":"","speakableText":"","speakableType":"","text":"","title":"","updated":""}'
};

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 = @{ @"attachments": @[ @{ @"contentType": @"", @"contentUrl": @"", @"id": @"", @"isProcessingContent": @NO } ],
                              @"bundleId": @"",
                              @"canonicalUrl": @"",
                              @"created": @"",
                              @"creator": @{ @"acceptCommands": @[ @{ @"type": @"" } ], @"acceptTypes": @[  ], @"displayName": @"", @"id": @"", @"imageUrls": @[  ], @"kind": @"", @"phoneNumber": @"", @"priority": @0, @"sharingFeatures": @[  ], @"source": @"", @"speakableName": @"", @"type": @"" },
                              @"displayTime": @"",
                              @"etag": @"",
                              @"html": @"",
                              @"id": @"",
                              @"inReplyTo": @"",
                              @"isBundleCover": @NO,
                              @"isDeleted": @NO,
                              @"isPinned": @NO,
                              @"kind": @"",
                              @"location": @{ @"accuracy": @"", @"address": @"", @"displayName": @"", @"id": @"", @"kind": @"", @"latitude": @"", @"longitude": @"", @"timestamp": @"" },
                              @"menuItems": @[ @{ @"action": @"", @"contextual_command": @"", @"id": @"", @"payload": @"", @"removeWhenSelected": @NO, @"values": @[ @{ @"displayName": @"", @"iconUrl": @"", @"state": @"" } ] } ],
                              @"notification": @{ @"deliveryTime": @"", @"level": @"" },
                              @"pinScore": @0,
                              @"recipients": @[ @{  } ],
                              @"selfLink": @"",
                              @"sourceItemId": @"",
                              @"speakableText": @"",
                              @"speakableType": @"",
                              @"text": @"",
                              @"title": @"",
                              @"updated": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/timeline/:id"]
                                                       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}}/timeline/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/timeline/:id",
  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([
    'attachments' => [
        [
                'contentType' => '',
                'contentUrl' => '',
                'id' => '',
                'isProcessingContent' => null
        ]
    ],
    'bundleId' => '',
    'canonicalUrl' => '',
    'created' => '',
    'creator' => [
        'acceptCommands' => [
                [
                                'type' => ''
                ]
        ],
        'acceptTypes' => [
                
        ],
        'displayName' => '',
        'id' => '',
        'imageUrls' => [
                
        ],
        'kind' => '',
        'phoneNumber' => '',
        'priority' => 0,
        'sharingFeatures' => [
                
        ],
        'source' => '',
        'speakableName' => '',
        'type' => ''
    ],
    'displayTime' => '',
    'etag' => '',
    'html' => '',
    'id' => '',
    'inReplyTo' => '',
    'isBundleCover' => null,
    'isDeleted' => null,
    'isPinned' => null,
    'kind' => '',
    'location' => [
        'accuracy' => '',
        'address' => '',
        'displayName' => '',
        'id' => '',
        'kind' => '',
        'latitude' => '',
        'longitude' => '',
        'timestamp' => ''
    ],
    'menuItems' => [
        [
                'action' => '',
                'contextual_command' => '',
                'id' => '',
                'payload' => '',
                'removeWhenSelected' => null,
                'values' => [
                                [
                                                                'displayName' => '',
                                                                'iconUrl' => '',
                                                                'state' => ''
                                ]
                ]
        ]
    ],
    'notification' => [
        'deliveryTime' => '',
        'level' => ''
    ],
    'pinScore' => 0,
    'recipients' => [
        [
                
        ]
    ],
    'selfLink' => '',
    'sourceItemId' => '',
    'speakableText' => '',
    'speakableType' => '',
    'text' => '',
    'title' => '',
    'updated' => ''
  ]),
  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}}/timeline/:id', [
  'body' => '{
  "attachments": [
    {
      "contentType": "",
      "contentUrl": "",
      "id": "",
      "isProcessingContent": false
    }
  ],
  "bundleId": "",
  "canonicalUrl": "",
  "created": "",
  "creator": {
    "acceptCommands": [
      {
        "type": ""
      }
    ],
    "acceptTypes": [],
    "displayName": "",
    "id": "",
    "imageUrls": [],
    "kind": "",
    "phoneNumber": "",
    "priority": 0,
    "sharingFeatures": [],
    "source": "",
    "speakableName": "",
    "type": ""
  },
  "displayTime": "",
  "etag": "",
  "html": "",
  "id": "",
  "inReplyTo": "",
  "isBundleCover": false,
  "isDeleted": false,
  "isPinned": false,
  "kind": "",
  "location": {
    "accuracy": "",
    "address": "",
    "displayName": "",
    "id": "",
    "kind": "",
    "latitude": "",
    "longitude": "",
    "timestamp": ""
  },
  "menuItems": [
    {
      "action": "",
      "contextual_command": "",
      "id": "",
      "payload": "",
      "removeWhenSelected": false,
      "values": [
        {
          "displayName": "",
          "iconUrl": "",
          "state": ""
        }
      ]
    }
  ],
  "notification": {
    "deliveryTime": "",
    "level": ""
  },
  "pinScore": 0,
  "recipients": [
    {}
  ],
  "selfLink": "",
  "sourceItemId": "",
  "speakableText": "",
  "speakableType": "",
  "text": "",
  "title": "",
  "updated": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/timeline/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attachments' => [
    [
        'contentType' => '',
        'contentUrl' => '',
        'id' => '',
        'isProcessingContent' => null
    ]
  ],
  'bundleId' => '',
  'canonicalUrl' => '',
  'created' => '',
  'creator' => [
    'acceptCommands' => [
        [
                'type' => ''
        ]
    ],
    'acceptTypes' => [
        
    ],
    'displayName' => '',
    'id' => '',
    'imageUrls' => [
        
    ],
    'kind' => '',
    'phoneNumber' => '',
    'priority' => 0,
    'sharingFeatures' => [
        
    ],
    'source' => '',
    'speakableName' => '',
    'type' => ''
  ],
  'displayTime' => '',
  'etag' => '',
  'html' => '',
  'id' => '',
  'inReplyTo' => '',
  'isBundleCover' => null,
  'isDeleted' => null,
  'isPinned' => null,
  'kind' => '',
  'location' => [
    'accuracy' => '',
    'address' => '',
    'displayName' => '',
    'id' => '',
    'kind' => '',
    'latitude' => '',
    'longitude' => '',
    'timestamp' => ''
  ],
  'menuItems' => [
    [
        'action' => '',
        'contextual_command' => '',
        'id' => '',
        'payload' => '',
        'removeWhenSelected' => null,
        'values' => [
                [
                                'displayName' => '',
                                'iconUrl' => '',
                                'state' => ''
                ]
        ]
    ]
  ],
  'notification' => [
    'deliveryTime' => '',
    'level' => ''
  ],
  'pinScore' => 0,
  'recipients' => [
    [
        
    ]
  ],
  'selfLink' => '',
  'sourceItemId' => '',
  'speakableText' => '',
  'speakableType' => '',
  'text' => '',
  'title' => '',
  'updated' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'attachments' => [
    [
        'contentType' => '',
        'contentUrl' => '',
        'id' => '',
        'isProcessingContent' => null
    ]
  ],
  'bundleId' => '',
  'canonicalUrl' => '',
  'created' => '',
  'creator' => [
    'acceptCommands' => [
        [
                'type' => ''
        ]
    ],
    'acceptTypes' => [
        
    ],
    'displayName' => '',
    'id' => '',
    'imageUrls' => [
        
    ],
    'kind' => '',
    'phoneNumber' => '',
    'priority' => 0,
    'sharingFeatures' => [
        
    ],
    'source' => '',
    'speakableName' => '',
    'type' => ''
  ],
  'displayTime' => '',
  'etag' => '',
  'html' => '',
  'id' => '',
  'inReplyTo' => '',
  'isBundleCover' => null,
  'isDeleted' => null,
  'isPinned' => null,
  'kind' => '',
  'location' => [
    'accuracy' => '',
    'address' => '',
    'displayName' => '',
    'id' => '',
    'kind' => '',
    'latitude' => '',
    'longitude' => '',
    'timestamp' => ''
  ],
  'menuItems' => [
    [
        'action' => '',
        'contextual_command' => '',
        'id' => '',
        'payload' => '',
        'removeWhenSelected' => null,
        'values' => [
                [
                                'displayName' => '',
                                'iconUrl' => '',
                                'state' => ''
                ]
        ]
    ]
  ],
  'notification' => [
    'deliveryTime' => '',
    'level' => ''
  ],
  'pinScore' => 0,
  'recipients' => [
    [
        
    ]
  ],
  'selfLink' => '',
  'sourceItemId' => '',
  'speakableText' => '',
  'speakableType' => '',
  'text' => '',
  'title' => '',
  'updated' => ''
]));
$request->setRequestUrl('{{baseUrl}}/timeline/:id');
$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}}/timeline/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "attachments": [
    {
      "contentType": "",
      "contentUrl": "",
      "id": "",
      "isProcessingContent": false
    }
  ],
  "bundleId": "",
  "canonicalUrl": "",
  "created": "",
  "creator": {
    "acceptCommands": [
      {
        "type": ""
      }
    ],
    "acceptTypes": [],
    "displayName": "",
    "id": "",
    "imageUrls": [],
    "kind": "",
    "phoneNumber": "",
    "priority": 0,
    "sharingFeatures": [],
    "source": "",
    "speakableName": "",
    "type": ""
  },
  "displayTime": "",
  "etag": "",
  "html": "",
  "id": "",
  "inReplyTo": "",
  "isBundleCover": false,
  "isDeleted": false,
  "isPinned": false,
  "kind": "",
  "location": {
    "accuracy": "",
    "address": "",
    "displayName": "",
    "id": "",
    "kind": "",
    "latitude": "",
    "longitude": "",
    "timestamp": ""
  },
  "menuItems": [
    {
      "action": "",
      "contextual_command": "",
      "id": "",
      "payload": "",
      "removeWhenSelected": false,
      "values": [
        {
          "displayName": "",
          "iconUrl": "",
          "state": ""
        }
      ]
    }
  ],
  "notification": {
    "deliveryTime": "",
    "level": ""
  },
  "pinScore": 0,
  "recipients": [
    {}
  ],
  "selfLink": "",
  "sourceItemId": "",
  "speakableText": "",
  "speakableType": "",
  "text": "",
  "title": "",
  "updated": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeline/:id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "attachments": [
    {
      "contentType": "",
      "contentUrl": "",
      "id": "",
      "isProcessingContent": false
    }
  ],
  "bundleId": "",
  "canonicalUrl": "",
  "created": "",
  "creator": {
    "acceptCommands": [
      {
        "type": ""
      }
    ],
    "acceptTypes": [],
    "displayName": "",
    "id": "",
    "imageUrls": [],
    "kind": "",
    "phoneNumber": "",
    "priority": 0,
    "sharingFeatures": [],
    "source": "",
    "speakableName": "",
    "type": ""
  },
  "displayTime": "",
  "etag": "",
  "html": "",
  "id": "",
  "inReplyTo": "",
  "isBundleCover": false,
  "isDeleted": false,
  "isPinned": false,
  "kind": "",
  "location": {
    "accuracy": "",
    "address": "",
    "displayName": "",
    "id": "",
    "kind": "",
    "latitude": "",
    "longitude": "",
    "timestamp": ""
  },
  "menuItems": [
    {
      "action": "",
      "contextual_command": "",
      "id": "",
      "payload": "",
      "removeWhenSelected": false,
      "values": [
        {
          "displayName": "",
          "iconUrl": "",
          "state": ""
        }
      ]
    }
  ],
  "notification": {
    "deliveryTime": "",
    "level": ""
  },
  "pinScore": 0,
  "recipients": [
    {}
  ],
  "selfLink": "",
  "sourceItemId": "",
  "speakableText": "",
  "speakableType": "",
  "text": "",
  "title": "",
  "updated": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/timeline/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/timeline/:id"

payload = {
    "attachments": [
        {
            "contentType": "",
            "contentUrl": "",
            "id": "",
            "isProcessingContent": False
        }
    ],
    "bundleId": "",
    "canonicalUrl": "",
    "created": "",
    "creator": {
        "acceptCommands": [{ "type": "" }],
        "acceptTypes": [],
        "displayName": "",
        "id": "",
        "imageUrls": [],
        "kind": "",
        "phoneNumber": "",
        "priority": 0,
        "sharingFeatures": [],
        "source": "",
        "speakableName": "",
        "type": ""
    },
    "displayTime": "",
    "etag": "",
    "html": "",
    "id": "",
    "inReplyTo": "",
    "isBundleCover": False,
    "isDeleted": False,
    "isPinned": False,
    "kind": "",
    "location": {
        "accuracy": "",
        "address": "",
        "displayName": "",
        "id": "",
        "kind": "",
        "latitude": "",
        "longitude": "",
        "timestamp": ""
    },
    "menuItems": [
        {
            "action": "",
            "contextual_command": "",
            "id": "",
            "payload": "",
            "removeWhenSelected": False,
            "values": [
                {
                    "displayName": "",
                    "iconUrl": "",
                    "state": ""
                }
            ]
        }
    ],
    "notification": {
        "deliveryTime": "",
        "level": ""
    },
    "pinScore": 0,
    "recipients": [{}],
    "selfLink": "",
    "sourceItemId": "",
    "speakableText": "",
    "speakableType": "",
    "text": "",
    "title": "",
    "updated": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeline/:id"

payload <- "{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\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}}/timeline/:id")

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  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\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/timeline/:id') do |req|
  req.body = "{\n  \"attachments\": [\n    {\n      \"contentType\": \"\",\n      \"contentUrl\": \"\",\n      \"id\": \"\",\n      \"isProcessingContent\": false\n    }\n  ],\n  \"bundleId\": \"\",\n  \"canonicalUrl\": \"\",\n  \"created\": \"\",\n  \"creator\": {\n    \"acceptCommands\": [\n      {\n        \"type\": \"\"\n      }\n    ],\n    \"acceptTypes\": [],\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"imageUrls\": [],\n    \"kind\": \"\",\n    \"phoneNumber\": \"\",\n    \"priority\": 0,\n    \"sharingFeatures\": [],\n    \"source\": \"\",\n    \"speakableName\": \"\",\n    \"type\": \"\"\n  },\n  \"displayTime\": \"\",\n  \"etag\": \"\",\n  \"html\": \"\",\n  \"id\": \"\",\n  \"inReplyTo\": \"\",\n  \"isBundleCover\": false,\n  \"isDeleted\": false,\n  \"isPinned\": false,\n  \"kind\": \"\",\n  \"location\": {\n    \"accuracy\": \"\",\n    \"address\": \"\",\n    \"displayName\": \"\",\n    \"id\": \"\",\n    \"kind\": \"\",\n    \"latitude\": \"\",\n    \"longitude\": \"\",\n    \"timestamp\": \"\"\n  },\n  \"menuItems\": [\n    {\n      \"action\": \"\",\n      \"contextual_command\": \"\",\n      \"id\": \"\",\n      \"payload\": \"\",\n      \"removeWhenSelected\": false,\n      \"values\": [\n        {\n          \"displayName\": \"\",\n          \"iconUrl\": \"\",\n          \"state\": \"\"\n        }\n      ]\n    }\n  ],\n  \"notification\": {\n    \"deliveryTime\": \"\",\n    \"level\": \"\"\n  },\n  \"pinScore\": 0,\n  \"recipients\": [\n    {}\n  ],\n  \"selfLink\": \"\",\n  \"sourceItemId\": \"\",\n  \"speakableText\": \"\",\n  \"speakableType\": \"\",\n  \"text\": \"\",\n  \"title\": \"\",\n  \"updated\": \"\"\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}}/timeline/:id";

    let payload = json!({
        "attachments": (
            json!({
                "contentType": "",
                "contentUrl": "",
                "id": "",
                "isProcessingContent": false
            })
        ),
        "bundleId": "",
        "canonicalUrl": "",
        "created": "",
        "creator": json!({
            "acceptCommands": (json!({"type": ""})),
            "acceptTypes": (),
            "displayName": "",
            "id": "",
            "imageUrls": (),
            "kind": "",
            "phoneNumber": "",
            "priority": 0,
            "sharingFeatures": (),
            "source": "",
            "speakableName": "",
            "type": ""
        }),
        "displayTime": "",
        "etag": "",
        "html": "",
        "id": "",
        "inReplyTo": "",
        "isBundleCover": false,
        "isDeleted": false,
        "isPinned": false,
        "kind": "",
        "location": json!({
            "accuracy": "",
            "address": "",
            "displayName": "",
            "id": "",
            "kind": "",
            "latitude": "",
            "longitude": "",
            "timestamp": ""
        }),
        "menuItems": (
            json!({
                "action": "",
                "contextual_command": "",
                "id": "",
                "payload": "",
                "removeWhenSelected": false,
                "values": (
                    json!({
                        "displayName": "",
                        "iconUrl": "",
                        "state": ""
                    })
                )
            })
        ),
        "notification": json!({
            "deliveryTime": "",
            "level": ""
        }),
        "pinScore": 0,
        "recipients": (json!({})),
        "selfLink": "",
        "sourceItemId": "",
        "speakableText": "",
        "speakableType": "",
        "text": "",
        "title": "",
        "updated": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/timeline/:id \
  --header 'content-type: application/json' \
  --data '{
  "attachments": [
    {
      "contentType": "",
      "contentUrl": "",
      "id": "",
      "isProcessingContent": false
    }
  ],
  "bundleId": "",
  "canonicalUrl": "",
  "created": "",
  "creator": {
    "acceptCommands": [
      {
        "type": ""
      }
    ],
    "acceptTypes": [],
    "displayName": "",
    "id": "",
    "imageUrls": [],
    "kind": "",
    "phoneNumber": "",
    "priority": 0,
    "sharingFeatures": [],
    "source": "",
    "speakableName": "",
    "type": ""
  },
  "displayTime": "",
  "etag": "",
  "html": "",
  "id": "",
  "inReplyTo": "",
  "isBundleCover": false,
  "isDeleted": false,
  "isPinned": false,
  "kind": "",
  "location": {
    "accuracy": "",
    "address": "",
    "displayName": "",
    "id": "",
    "kind": "",
    "latitude": "",
    "longitude": "",
    "timestamp": ""
  },
  "menuItems": [
    {
      "action": "",
      "contextual_command": "",
      "id": "",
      "payload": "",
      "removeWhenSelected": false,
      "values": [
        {
          "displayName": "",
          "iconUrl": "",
          "state": ""
        }
      ]
    }
  ],
  "notification": {
    "deliveryTime": "",
    "level": ""
  },
  "pinScore": 0,
  "recipients": [
    {}
  ],
  "selfLink": "",
  "sourceItemId": "",
  "speakableText": "",
  "speakableType": "",
  "text": "",
  "title": "",
  "updated": ""
}'

echo '{
  "attachments": [
    {
      "contentType": "",
      "contentUrl": "",
      "id": "",
      "isProcessingContent": false
    }
  ],
  "bundleId": "",
  "canonicalUrl": "",
  "created": "",
  "creator": {
    "acceptCommands": [
      {
        "type": ""
      }
    ],
    "acceptTypes": [],
    "displayName": "",
    "id": "",
    "imageUrls": [],
    "kind": "",
    "phoneNumber": "",
    "priority": 0,
    "sharingFeatures": [],
    "source": "",
    "speakableName": "",
    "type": ""
  },
  "displayTime": "",
  "etag": "",
  "html": "",
  "id": "",
  "inReplyTo": "",
  "isBundleCover": false,
  "isDeleted": false,
  "isPinned": false,
  "kind": "",
  "location": {
    "accuracy": "",
    "address": "",
    "displayName": "",
    "id": "",
    "kind": "",
    "latitude": "",
    "longitude": "",
    "timestamp": ""
  },
  "menuItems": [
    {
      "action": "",
      "contextual_command": "",
      "id": "",
      "payload": "",
      "removeWhenSelected": false,
      "values": [
        {
          "displayName": "",
          "iconUrl": "",
          "state": ""
        }
      ]
    }
  ],
  "notification": {
    "deliveryTime": "",
    "level": ""
  },
  "pinScore": 0,
  "recipients": [
    {}
  ],
  "selfLink": "",
  "sourceItemId": "",
  "speakableText": "",
  "speakableType": "",
  "text": "",
  "title": "",
  "updated": ""
}' |  \
  http PATCH {{baseUrl}}/timeline/:id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "attachments": [\n    {\n      "contentType": "",\n      "contentUrl": "",\n      "id": "",\n      "isProcessingContent": false\n    }\n  ],\n  "bundleId": "",\n  "canonicalUrl": "",\n  "created": "",\n  "creator": {\n    "acceptCommands": [\n      {\n        "type": ""\n      }\n    ],\n    "acceptTypes": [],\n    "displayName": "",\n    "id": "",\n    "imageUrls": [],\n    "kind": "",\n    "phoneNumber": "",\n    "priority": 0,\n    "sharingFeatures": [],\n    "source": "",\n    "speakableName": "",\n    "type": ""\n  },\n  "displayTime": "",\n  "etag": "",\n  "html": "",\n  "id": "",\n  "inReplyTo": "",\n  "isBundleCover": false,\n  "isDeleted": false,\n  "isPinned": false,\n  "kind": "",\n  "location": {\n    "accuracy": "",\n    "address": "",\n    "displayName": "",\n    "id": "",\n    "kind": "",\n    "latitude": "",\n    "longitude": "",\n    "timestamp": ""\n  },\n  "menuItems": [\n    {\n      "action": "",\n      "contextual_command": "",\n      "id": "",\n      "payload": "",\n      "removeWhenSelected": false,\n      "values": [\n        {\n          "displayName": "",\n          "iconUrl": "",\n          "state": ""\n        }\n      ]\n    }\n  ],\n  "notification": {\n    "deliveryTime": "",\n    "level": ""\n  },\n  "pinScore": 0,\n  "recipients": [\n    {}\n  ],\n  "selfLink": "",\n  "sourceItemId": "",\n  "speakableText": "",\n  "speakableType": "",\n  "text": "",\n  "title": "",\n  "updated": ""\n}' \
  --output-document \
  - {{baseUrl}}/timeline/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attachments": [
    [
      "contentType": "",
      "contentUrl": "",
      "id": "",
      "isProcessingContent": false
    ]
  ],
  "bundleId": "",
  "canonicalUrl": "",
  "created": "",
  "creator": [
    "acceptCommands": [["type": ""]],
    "acceptTypes": [],
    "displayName": "",
    "id": "",
    "imageUrls": [],
    "kind": "",
    "phoneNumber": "",
    "priority": 0,
    "sharingFeatures": [],
    "source": "",
    "speakableName": "",
    "type": ""
  ],
  "displayTime": "",
  "etag": "",
  "html": "",
  "id": "",
  "inReplyTo": "",
  "isBundleCover": false,
  "isDeleted": false,
  "isPinned": false,
  "kind": "",
  "location": [
    "accuracy": "",
    "address": "",
    "displayName": "",
    "id": "",
    "kind": "",
    "latitude": "",
    "longitude": "",
    "timestamp": ""
  ],
  "menuItems": [
    [
      "action": "",
      "contextual_command": "",
      "id": "",
      "payload": "",
      "removeWhenSelected": false,
      "values": [
        [
          "displayName": "",
          "iconUrl": "",
          "state": ""
        ]
      ]
    ]
  ],
  "notification": [
    "deliveryTime": "",
    "level": ""
  ],
  "pinScore": 0,
  "recipients": [[]],
  "selfLink": "",
  "sourceItemId": "",
  "speakableText": "",
  "speakableType": "",
  "text": "",
  "title": "",
  "updated": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timeline/:id")! 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()

PUT mirror.timeline.update

{{baseUrl}}/timeline/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timeline/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/timeline/:id")

require "http/client"

url = "{{baseUrl}}/timeline/:id"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/timeline/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/timeline/:id");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/timeline/:id"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/timeline/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/timeline/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/timeline/:id"))
    .method("PUT", 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}}/timeline/:id")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/timeline/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/timeline/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/timeline/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/timeline/:id';
const options = {method: 'PUT'};

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}}/timeline/:id',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/timeline/:id")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/timeline/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'PUT', url: '{{baseUrl}}/timeline/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/timeline/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'PUT', url: '{{baseUrl}}/timeline/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/timeline/:id';
const options = {method: 'PUT'};

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}}/timeline/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/timeline/:id" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/timeline/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/timeline/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/timeline/:id');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/timeline/:id');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/timeline/:id' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeline/:id' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/timeline/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/timeline/:id"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeline/:id"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeline/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/timeline/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/timeline/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/timeline/:id

http PUT {{baseUrl}}/timeline/:id

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/timeline/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timeline/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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()