xRegistry API

GET getCapabilities

{{baseUrl}}/capabilities

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/capabilities"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/capabilities"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

    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}}/capabilities

http GET {{baseUrl}}/capabilities

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

import Foundation

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

{{baseUrl}}/capabilities

BODY json

{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/capabilities");

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  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/capabilities" {:content-type :json
                                                          :form-params {:enforcecompatibility false
                                                                        :flags []
                                                                        :mutable []
                                                                        :pagination false
                                                                        :schemas []
                                                                        :shortself false
                                                                        :specversions []
                                                                        :sticky false}})

require "http/client"

url = "{{baseUrl}}/capabilities"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\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}}/capabilities"),
    Content = new StringContent("{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/capabilities");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\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/capabilities HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 170

{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/capabilities")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/capabilities"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/capabilities")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/capabilities")
  .header("content-type", "application/json")
  .body("{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}")
  .asString();

const data = JSON.stringify({
  enforcecompatibility: false,
  flags: [],
  mutable: [],
  pagination: false,
  schemas: [],
  shortself: false,
  specversions: [],
  sticky: false
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/capabilities',
  headers: {'content-type': 'application/json'},
  data: {
    enforcecompatibility: false,
    flags: [],
    mutable: [],
    pagination: false,
    schemas: [],
    shortself: false,
    specversions: [],
    sticky: false
  }
};

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

const url = '{{baseUrl}}/capabilities';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"enforcecompatibility":false,"flags":[],"mutable":[],"pagination":false,"schemas":[],"shortself":false,"specversions":[],"sticky":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/capabilities',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "enforcecompatibility": false,\n  "flags": [],\n  "mutable": [],\n  "pagination": false,\n  "schemas": [],\n  "shortself": false,\n  "specversions": [],\n  "sticky": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/capabilities")
  .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/capabilities',
  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({
  enforcecompatibility: false,
  flags: [],
  mutable: [],
  pagination: false,
  schemas: [],
  shortself: false,
  specversions: [],
  sticky: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/capabilities',
  headers: {'content-type': 'application/json'},
  body: {
    enforcecompatibility: false,
    flags: [],
    mutable: [],
    pagination: false,
    schemas: [],
    shortself: false,
    specversions: [],
    sticky: false
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/capabilities');

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

req.type('json');
req.send({
  enforcecompatibility: false,
  flags: [],
  mutable: [],
  pagination: false,
  schemas: [],
  shortself: false,
  specversions: [],
  sticky: false
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/capabilities',
  headers: {'content-type': 'application/json'},
  data: {
    enforcecompatibility: false,
    flags: [],
    mutable: [],
    pagination: false,
    schemas: [],
    shortself: false,
    specversions: [],
    sticky: false
  }
};

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

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

const url = '{{baseUrl}}/capabilities';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"enforcecompatibility":false,"flags":[],"mutable":[],"pagination":false,"schemas":[],"shortself":false,"specversions":[],"sticky":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"enforcecompatibility": @NO,
                              @"flags": @[  ],
                              @"mutable": @[  ],
                              @"pagination": @NO,
                              @"schemas": @[  ],
                              @"shortself": @NO,
                              @"specversions": @[  ],
                              @"sticky": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/capabilities"]
                                                       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}}/capabilities" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}" in

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

 "{{baseUrl}}/capabilities",
  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([
    'enforcecompatibility' => null,
    'flags' => [
        
    ],
    'mutable' => [
        
    ],
    'pagination' => null,
    'schemas' => [
        
    ],
    'shortself' => null,
    'specversions' => [
        
    ],
    'sticky' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/capabilities', [
  'body' => '{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'enforcecompatibility' => null,
  'flags' => [
    
  ],
  'mutable' => [
    
  ],
  'pagination' => null,
  'schemas' => [
    
  ],
  'shortself' => null,
  'specversions' => [
    
  ],
  'sticky' => null
]));

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

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

append(json_encode([
  'enforcecompatibility' => null,
  'flags' => [
    
  ],
  'mutable' => [
    
  ],
  'pagination' => null,
  'schemas' => [
    
  ],
  'shortself' => null,
  'specversions' => [
    
  ],
  'sticky' => null
]));
$request->setRequestUrl('{{baseUrl}}/capabilities');
$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}}/capabilities' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/capabilities' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}'

import http.client

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

payload = "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}"

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

conn.request("PATCH", "/baseUrl/capabilities", payload, headers)

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

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

import requests

url = "{{baseUrl}}/capabilities"

payload = {
    "enforcecompatibility": False,
    "flags": [],
    "mutable": [],
    "pagination": False,
    "schemas": [],
    "shortself": False,
    "specversions": [],
    "sticky": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\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}}/capabilities")

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  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/capabilities') do |req|
  req.body = "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\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}}/capabilities";

    let payload = json!({
        "enforcecompatibility": false,
        "flags": (),
        "mutable": (),
        "pagination": false,
        "schemas": (),
        "shortself": false,
        "specversions": (),
        "sticky": false
    });

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

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

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/capabilities \
  --header 'content-type: application/json' \
  --data '{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}'

echo '{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}' |  \
  http PATCH {{baseUrl}}/capabilities \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "enforcecompatibility": false,\n  "flags": [],\n  "mutable": [],\n  "pagination": false,\n  "schemas": [],\n  "shortself": false,\n  "specversions": [],\n  "sticky": false\n}' \
  --output-document \
  - {{baseUrl}}/capabilities

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
] as [String : Any]

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

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

{{baseUrl}}/capabilities

BODY json

{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/capabilities");

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  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/capabilities" {:content-type :json
                                                        :form-params {:enforcecompatibility false
                                                                      :flags []
                                                                      :mutable []
                                                                      :pagination false
                                                                      :schemas []
                                                                      :shortself false
                                                                      :specversions []
                                                                      :sticky false}})

require "http/client"

url = "{{baseUrl}}/capabilities"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\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}}/capabilities"),
    Content = new StringContent("{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/capabilities");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\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/capabilities HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 170

{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/capabilities")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/capabilities"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/capabilities")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/capabilities")
  .header("content-type", "application/json")
  .body("{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}")
  .asString();

const data = JSON.stringify({
  enforcecompatibility: false,
  flags: [],
  mutable: [],
  pagination: false,
  schemas: [],
  shortself: false,
  specversions: [],
  sticky: false
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/capabilities',
  headers: {'content-type': 'application/json'},
  data: {
    enforcecompatibility: false,
    flags: [],
    mutable: [],
    pagination: false,
    schemas: [],
    shortself: false,
    specversions: [],
    sticky: false
  }
};

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

const url = '{{baseUrl}}/capabilities';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"enforcecompatibility":false,"flags":[],"mutable":[],"pagination":false,"schemas":[],"shortself":false,"specversions":[],"sticky":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/capabilities',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "enforcecompatibility": false,\n  "flags": [],\n  "mutable": [],\n  "pagination": false,\n  "schemas": [],\n  "shortself": false,\n  "specversions": [],\n  "sticky": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/capabilities")
  .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/capabilities',
  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({
  enforcecompatibility: false,
  flags: [],
  mutable: [],
  pagination: false,
  schemas: [],
  shortself: false,
  specversions: [],
  sticky: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/capabilities',
  headers: {'content-type': 'application/json'},
  body: {
    enforcecompatibility: false,
    flags: [],
    mutable: [],
    pagination: false,
    schemas: [],
    shortself: false,
    specversions: [],
    sticky: false
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/capabilities');

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

req.type('json');
req.send({
  enforcecompatibility: false,
  flags: [],
  mutable: [],
  pagination: false,
  schemas: [],
  shortself: false,
  specversions: [],
  sticky: false
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/capabilities',
  headers: {'content-type': 'application/json'},
  data: {
    enforcecompatibility: false,
    flags: [],
    mutable: [],
    pagination: false,
    schemas: [],
    shortself: false,
    specversions: [],
    sticky: false
  }
};

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

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

const url = '{{baseUrl}}/capabilities';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"enforcecompatibility":false,"flags":[],"mutable":[],"pagination":false,"schemas":[],"shortself":false,"specversions":[],"sticky":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"enforcecompatibility": @NO,
                              @"flags": @[  ],
                              @"mutable": @[  ],
                              @"pagination": @NO,
                              @"schemas": @[  ],
                              @"shortself": @NO,
                              @"specversions": @[  ],
                              @"sticky": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/capabilities"]
                                                       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}}/capabilities" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}" in

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

 "{{baseUrl}}/capabilities",
  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([
    'enforcecompatibility' => null,
    'flags' => [
        
    ],
    'mutable' => [
        
    ],
    'pagination' => null,
    'schemas' => [
        
    ],
    'shortself' => null,
    'specversions' => [
        
    ],
    'sticky' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/capabilities', [
  'body' => '{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/capabilities');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'enforcecompatibility' => null,
  'flags' => [
    
  ],
  'mutable' => [
    
  ],
  'pagination' => null,
  'schemas' => [
    
  ],
  'shortself' => null,
  'specversions' => [
    
  ],
  'sticky' => null
]));

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

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

append(json_encode([
  'enforcecompatibility' => null,
  'flags' => [
    
  ],
  'mutable' => [
    
  ],
  'pagination' => null,
  'schemas' => [
    
  ],
  'shortself' => null,
  'specversions' => [
    
  ],
  'sticky' => null
]));
$request->setRequestUrl('{{baseUrl}}/capabilities');
$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}}/capabilities' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/capabilities' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}'

import http.client

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

payload = "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}"

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

conn.request("PUT", "/baseUrl/capabilities", payload, headers)

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

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

import requests

url = "{{baseUrl}}/capabilities"

payload = {
    "enforcecompatibility": False,
    "flags": [],
    "mutable": [],
    "pagination": False,
    "schemas": [],
    "shortself": False,
    "specversions": [],
    "sticky": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\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}}/capabilities")

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  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/capabilities') do |req|
  req.body = "{\n  \"enforcecompatibility\": false,\n  \"flags\": [],\n  \"mutable\": [],\n  \"pagination\": false,\n  \"schemas\": [],\n  \"shortself\": false,\n  \"specversions\": [],\n  \"sticky\": false\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}}/capabilities";

    let payload = json!({
        "enforcecompatibility": false,
        "flags": (),
        "mutable": (),
        "pagination": false,
        "schemas": (),
        "shortself": false,
        "specversions": (),
        "sticky": false
    });

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/capabilities \
  --header 'content-type: application/json' \
  --data '{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}'

echo '{
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
}' |  \
  http PUT {{baseUrl}}/capabilities \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "enforcecompatibility": false,\n  "flags": [],\n  "mutable": [],\n  "pagination": false,\n  "schemas": [],\n  "shortself": false,\n  "specversions": [],\n  "sticky": false\n}' \
  --output-document \
  - {{baseUrl}}/capabilities

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "enforcecompatibility": false,
  "flags": [],
  "mutable": [],
  "pagination": false,
  "schemas": [],
  "shortself": false,
  "specversions": [],
  "sticky": false
] as [String : Any]

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

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

{{baseUrl}}/export

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/export"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/export"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

    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}}/export

http GET {{baseUrl}}/export

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

import Foundation

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

{{baseUrl}}/model

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/model"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/model"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

    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}}/model

http GET {{baseUrl}}/model

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

import Foundation

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

{{baseUrl}}/model

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/model");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/model" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/model"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/model"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/model");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{}")

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

{}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/model"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/model")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/model")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/model',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/model';
const options = {method: 'PATCH', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/model',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

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

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

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

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

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/model',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/model');

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

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

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/model',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

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

const url = '{{baseUrl}}/model';
const options = {method: 'PATCH', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/model');
$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}}/model' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/model' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("PATCH", "/baseUrl/model", payload, headers)

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

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

import requests

url = "{{baseUrl}}/model"

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

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

print(response.json())

library(httr)

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

payload <- "{}"

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}}/model")

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 = "{}"

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/model') do |req|
  req.body = "{}"
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}}/model";

    let payload = json!({});

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

    let client = reqwest::Client::new();
    let response = client.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}}/model \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http PATCH {{baseUrl}}/model \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/model

import Foundation

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

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

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

{{baseUrl}}/model

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/model");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/model" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/model"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/model"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/model");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{}")

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

{}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/model"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/model")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/model")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/model',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/model';
const options = {method: 'PUT', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/model',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

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

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

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

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

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/model',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/model');

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

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

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/model',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

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

const url = '{{baseUrl}}/model';
const options = {method: 'PUT', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/model');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/model');
$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}}/model' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/model' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("PUT", "/baseUrl/model", payload, headers)

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

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

import requests

url = "{{baseUrl}}/model"

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

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

print(response.json())

library(httr)

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

payload <- "{}"

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}}/model")

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 = "{}"

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/model') do |req|
  req.body = "{}"
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}}/model";

    let payload = json!({});

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

    let client = reqwest::Client::new();
    let response = client.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}}/model \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http PUT {{baseUrl}}/model \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/model

import Foundation

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

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

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

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid

QUERY PARAMS

epoch

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid" {:query-params {:epoch ""}})

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch="

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}}/messagegroups/:groupid/messages/:resourceid?epoch="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch="

	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/messagegroups/:groupid/messages/:resourceid?epoch= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch="))
    .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}}/messagegroups/:groupid/messages/:resourceid?epoch=")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=")
  .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}}/messagegroups/:groupid/messages/:resourceid?epoch=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid',
  params: {epoch: ''}
};

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=';
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}}/messagegroups/:groupid/messages/:resourceid?epoch=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/messagegroups/:groupid/messages/:resourceid?epoch=',
  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}}/messagegroups/:groupid/messages/:resourceid',
  qs: {epoch: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');

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

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}}/messagegroups/:groupid/messages/:resourceid',
  params: {epoch: ''}
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=';
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}}/messagegroups/:groupid/messages/:resourceid?epoch="]
                                                       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}}/messagegroups/:groupid/messages/:resourceid?epoch=" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=",
  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}}/messagegroups/:groupid/messages/:resourceid?epoch=');

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'epoch' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/messagegroups/:groupid/messages/:resourceid?epoch=")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

querystring = {"epoch":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

queryString <- list(epoch = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=")

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/messagegroups/:groupid/messages/:resourceid') do |req|
  req.params['epoch'] = ''
end

puts response.status
puts response.body

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

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

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch='

http DELETE '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid?epoch=")! 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 Post new resource version

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

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

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

	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/messagegroups/:groupid/messages/:resourceid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"))
    .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}}/messagegroups/:groupid/messages/:resourceid")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")
  .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}}/messagegroups/:groupid/messages/:resourceid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid'
};

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid';
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}}/messagegroups/:groupid/messages/:resourceid',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/messagegroups/:groupid/messages/:resourceid',
  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}}/messagegroups/:groupid/messages/:resourceid'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');

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}}/messagegroups/:groupid/messages/:resourceid'
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid';
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}}/messagegroups/:groupid/messages/:resourceid"]
                                                       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}}/messagegroups/:groupid/messages/:resourceid" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid",
  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}}/messagegroups/:groupid/messages/:resourceid');

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/messagegroups/:groupid/messages/:resourceid")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")

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/messagegroups/:groupid/messages/:resourceid') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/messagegroups/:groupid/messages/:resourceid

http POST {{baseUrl}}/messagegroups/:groupid/messages/:resourceid

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid/messages/:resourceid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")! 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 getMessagegroupMessage

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

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

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

	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/messagegroups/:groupid/messages/:resourceid HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")
  .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}}/messagegroups/:groupid/messages/:resourceid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');

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}}/messagegroups/:groupid/messages/:resourceid'
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid';
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}}/messagegroups/:groupid/messages/:resourceid"]
                                                       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}}/messagegroups/:groupid/messages/:resourceid" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid",
  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}}/messagegroups/:groupid/messages/:resourceid');

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/messagegroups/:groupid/messages/:resourceid")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")

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/messagegroups/:groupid/messages/:resourceid') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/messagegroups/:groupid/messages/:resourceid

http GET {{baseUrl}}/messagegroups/:groupid/messages/:resourceid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid/messages/:resourceid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")! 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 getMessagegroupMessageDetails

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details")

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details"

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}}/messagegroups/:groupid/messages/:resourceid$details"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details"

	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/messagegroups/:groupid/messages/:resourceid$details HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details"))
    .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}}/messagegroups/:groupid/messages/:resourceid$details")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details")
  .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}}/messagegroups/:groupid/messages/:resourceid$details');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details'
};

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details';
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}}/messagegroups/:groupid/messages/:resourceid$details',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details');

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}}/messagegroups/:groupid/messages/:resourceid$details'
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details';
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}}/messagegroups/:groupid/messages/:resourceid$details"]
                                                       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}}/messagegroups/:groupid/messages/:resourceid$details" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details",
  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}}/messagegroups/:groupid/messages/:resourceid$details');

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/messagegroups/:groupid/messages/:resourceid$details")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details")

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/messagegroups/:groupid/messages/:resourceid$details') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details";

    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}}/messagegroups/:groupid/messages/:resourceid$details'

http GET '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid$details")! 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 putMessagegroupMessage

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

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

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

	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/messagegroups/:groupid/messages/:resourceid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"))
    .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}}/messagegroups/:groupid/messages/:resourceid")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")
  .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}}/messagegroups/:groupid/messages/:resourceid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid'
};

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid';
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}}/messagegroups/:groupid/messages/:resourceid',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/messagegroups/:groupid/messages/:resourceid',
  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}}/messagegroups/:groupid/messages/:resourceid'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');

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}}/messagegroups/:groupid/messages/:resourceid'
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid';
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}}/messagegroups/:groupid/messages/:resourceid"]
                                                       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}}/messagegroups/:groupid/messages/:resourceid" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid",
  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}}/messagegroups/:groupid/messages/:resourceid');

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid' -Method PUT

import http.client

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

conn.request("PUT", "/baseUrl/messagegroups/:groupid/messages/:resourceid")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid")

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/messagegroups/:groupid/messages/:resourceid') do |req|
end

puts response.status
puts response.body

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

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

    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}}/messagegroups/:groupid/messages/:resourceid

http PUT {{baseUrl}}/messagegroups/:groupid/messages/:resourceid

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid/messages/:resourceid

import Foundation

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

GET getMessagegroupMessagesAll

{{baseUrl}}/messagegroups/:groupid/messages

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/messagegroups/:groupid/messages")

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/messagegroups/:groupid/messages'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/messagegroups/:groupid/messages');

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}}/messagegroups/:groupid/messages'
};

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

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

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

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

 "{{baseUrl}}/messagegroups/:groupid/messages",
  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}}/messagegroups/:groupid/messages');

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid/messages' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/messagegroups/:groupid/messages")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid/messages")

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/messagegroups/:groupid/messages') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/messagegroups/:groupid/messages

http GET {{baseUrl}}/messagegroups/:groupid/messages

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid/messages

import Foundation

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

{{baseUrl}}/messagegroups/:groupid

QUERY PARAMS

epoch

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid?epoch=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/messagegroups/:groupid" {:query-params {:epoch ""}})

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid?epoch="

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

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid?epoch=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid?epoch="

	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/messagegroups/:groupid?epoch= HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid?epoch="))
    .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}}/messagegroups/:groupid?epoch=")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/messagegroups/:groupid?epoch=")
  .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}}/messagegroups/:groupid?epoch=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/messagegroups/:groupid',
  params: {epoch: ''}
};

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

const url = '{{baseUrl}}/messagegroups/:groupid?epoch=';
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}}/messagegroups/:groupid?epoch=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid?epoch=")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/messagegroups/:groupid?epoch=',
  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}}/messagegroups/:groupid',
  qs: {epoch: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/messagegroups/:groupid');

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

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}}/messagegroups/:groupid',
  params: {epoch: ''}
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid?epoch=';
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}}/messagegroups/:groupid?epoch="]
                                                       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}}/messagegroups/:groupid?epoch=" in

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

 "{{baseUrl}}/messagegroups/:groupid?epoch=",
  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}}/messagegroups/:groupid?epoch=');

echo $response->getBody();

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

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

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

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

setRequestUrl('{{baseUrl}}/messagegroups/:groupid');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'epoch' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid?epoch=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid?epoch=' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/messagegroups/:groupid?epoch=")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid"

querystring = {"epoch":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid"

queryString <- list(epoch = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid?epoch=")

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/messagegroups/:groupid') do |req|
  req.params['epoch'] = ''
end

puts response.status
puts response.body

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

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

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/messagegroups/:groupid?epoch='

http DELETE '{{baseUrl}}/messagegroups/:groupid?epoch='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/messagegroups/:groupid?epoch='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid?epoch=")! 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 getMessagegroup

{{baseUrl}}/messagegroups/:groupid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/messagegroups/:groupid")

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/messagegroups/:groupid');

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}}/messagegroups/:groupid'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/messagegroups/:groupid")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid")

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/messagegroups/:groupid') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/messagegroups/:groupid

http GET {{baseUrl}}/messagegroups/:groupid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid

import Foundation

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

{{baseUrl}}/messagegroups/:groupid

BODY json

{
  "messagegroupid": "",
  "name": "",
  "epoch": 0,
  "self": "",
  "xid": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "envelope": "",
  "protocol": "",
  "messages": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid");

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  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/messagegroups/:groupid" {:content-type :json
                                                                  :form-params {:messagegroupid ""
                                                                                :name ""
                                                                                :epoch 0
                                                                                :self ""
                                                                                :xid ""
                                                                                :description ""
                                                                                :documentation ""
                                                                                :labels {}
                                                                                :createdat ""
                                                                                :modifiedat ""
                                                                                :envelope ""
                                                                                :protocol ""
                                                                                :messages {}}})

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\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}}/messagegroups/:groupid"),
    Content = new StringContent("{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\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}}/messagegroups/:groupid");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid"

	payload := strings.NewReader("{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\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/messagegroups/:groupid HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 234

{
  "messagegroupid": "",
  "name": "",
  "epoch": 0,
  "self": "",
  "xid": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "envelope": "",
  "protocol": "",
  "messages": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/messagegroups/:groupid")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\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  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/messagegroups/:groupid")
  .header("content-type", "application/json")
  .body("{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\n}")
  .asString();

const data = JSON.stringify({
  messagegroupid: '',
  name: '',
  epoch: 0,
  self: '',
  xid: '',
  description: '',
  documentation: '',
  labels: {},
  createdat: '',
  modifiedat: '',
  envelope: '',
  protocol: '',
  messages: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/messagegroups/:groupid',
  headers: {'content-type': 'application/json'},
  data: {
    messagegroupid: '',
    name: '',
    epoch: 0,
    self: '',
    xid: '',
    description: '',
    documentation: '',
    labels: {},
    createdat: '',
    modifiedat: '',
    envelope: '',
    protocol: '',
    messages: {}
  }
};

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

const url = '{{baseUrl}}/messagegroups/:groupid';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"messagegroupid":"","name":"","epoch":0,"self":"","xid":"","description":"","documentation":"","labels":{},"createdat":"","modifiedat":"","envelope":"","protocol":"","messages":{}}'
};

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}}/messagegroups/:groupid',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "messagegroupid": "",\n  "name": "",\n  "epoch": 0,\n  "self": "",\n  "xid": "",\n  "description": "",\n  "documentation": "",\n  "labels": {},\n  "createdat": "",\n  "modifiedat": "",\n  "envelope": "",\n  "protocol": "",\n  "messages": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid")
  .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/messagegroups/:groupid',
  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({
  messagegroupid: '',
  name: '',
  epoch: 0,
  self: '',
  xid: '',
  description: '',
  documentation: '',
  labels: {},
  createdat: '',
  modifiedat: '',
  envelope: '',
  protocol: '',
  messages: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/messagegroups/:groupid',
  headers: {'content-type': 'application/json'},
  body: {
    messagegroupid: '',
    name: '',
    epoch: 0,
    self: '',
    xid: '',
    description: '',
    documentation: '',
    labels: {},
    createdat: '',
    modifiedat: '',
    envelope: '',
    protocol: '',
    messages: {}
  },
  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}}/messagegroups/:groupid');

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

req.type('json');
req.send({
  messagegroupid: '',
  name: '',
  epoch: 0,
  self: '',
  xid: '',
  description: '',
  documentation: '',
  labels: {},
  createdat: '',
  modifiedat: '',
  envelope: '',
  protocol: '',
  messages: {}
});

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}}/messagegroups/:groupid',
  headers: {'content-type': 'application/json'},
  data: {
    messagegroupid: '',
    name: '',
    epoch: 0,
    self: '',
    xid: '',
    description: '',
    documentation: '',
    labels: {},
    createdat: '',
    modifiedat: '',
    envelope: '',
    protocol: '',
    messages: {}
  }
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"messagegroupid":"","name":"","epoch":0,"self":"","xid":"","description":"","documentation":"","labels":{},"createdat":"","modifiedat":"","envelope":"","protocol":"","messages":{}}'
};

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 = @{ @"messagegroupid": @"",
                              @"name": @"",
                              @"epoch": @0,
                              @"self": @"",
                              @"xid": @"",
                              @"description": @"",
                              @"documentation": @"",
                              @"labels": @{  },
                              @"createdat": @"",
                              @"modifiedat": @"",
                              @"envelope": @"",
                              @"protocol": @"",
                              @"messages": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messagegroups/:groupid"]
                                                       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}}/messagegroups/:groupid" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\n}" in

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

 "{{baseUrl}}/messagegroups/:groupid",
  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([
    'messagegroupid' => '',
    'name' => '',
    'epoch' => 0,
    'self' => '',
    'xid' => '',
    'description' => '',
    'documentation' => '',
    'labels' => [
        
    ],
    'createdat' => '',
    'modifiedat' => '',
    'envelope' => '',
    'protocol' => '',
    'messages' => [
        
    ]
  ]),
  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}}/messagegroups/:groupid', [
  'body' => '{
  "messagegroupid": "",
  "name": "",
  "epoch": 0,
  "self": "",
  "xid": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "envelope": "",
  "protocol": "",
  "messages": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'messagegroupid' => '',
  'name' => '',
  'epoch' => 0,
  'self' => '',
  'xid' => '',
  'description' => '',
  'documentation' => '',
  'labels' => [
    
  ],
  'createdat' => '',
  'modifiedat' => '',
  'envelope' => '',
  'protocol' => '',
  'messages' => [
    
  ]
]));

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

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

append(json_encode([
  'messagegroupid' => '',
  'name' => '',
  'epoch' => 0,
  'self' => '',
  'xid' => '',
  'description' => '',
  'documentation' => '',
  'labels' => [
    
  ],
  'createdat' => '',
  'modifiedat' => '',
  'envelope' => '',
  'protocol' => '',
  'messages' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/messagegroups/:groupid');
$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}}/messagegroups/:groupid' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "messagegroupid": "",
  "name": "",
  "epoch": 0,
  "self": "",
  "xid": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "envelope": "",
  "protocol": "",
  "messages": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "messagegroupid": "",
  "name": "",
  "epoch": 0,
  "self": "",
  "xid": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "envelope": "",
  "protocol": "",
  "messages": {}
}'

import http.client

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

payload = "{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\n}"

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

conn.request("PUT", "/baseUrl/messagegroups/:groupid", payload, headers)

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid"

payload = {
    "messagegroupid": "",
    "name": "",
    "epoch": 0,
    "self": "",
    "xid": "",
    "description": "",
    "documentation": "",
    "labels": {},
    "createdat": "",
    "modifiedat": "",
    "envelope": "",
    "protocol": "",
    "messages": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid"

payload <- "{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\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}}/messagegroups/:groupid")

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  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\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/messagegroups/:groupid') do |req|
  req.body = "{\n  \"messagegroupid\": \"\",\n  \"name\": \"\",\n  \"epoch\": 0,\n  \"self\": \"\",\n  \"xid\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"envelope\": \"\",\n  \"protocol\": \"\",\n  \"messages\": {}\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}}/messagegroups/:groupid";

    let payload = json!({
        "messagegroupid": "",
        "name": "",
        "epoch": 0,
        "self": "",
        "xid": "",
        "description": "",
        "documentation": "",
        "labels": json!({}),
        "createdat": "",
        "modifiedat": "",
        "envelope": "",
        "protocol": "",
        "messages": json!({})
    });

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/messagegroups/:groupid \
  --header 'content-type: application/json' \
  --data '{
  "messagegroupid": "",
  "name": "",
  "epoch": 0,
  "self": "",
  "xid": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "envelope": "",
  "protocol": "",
  "messages": {}
}'

echo '{
  "messagegroupid": "",
  "name": "",
  "epoch": 0,
  "self": "",
  "xid": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "envelope": "",
  "protocol": "",
  "messages": {}
}' |  \
  http PUT {{baseUrl}}/messagegroups/:groupid \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "messagegroupid": "",\n  "name": "",\n  "epoch": 0,\n  "self": "",\n  "xid": "",\n  "description": "",\n  "documentation": "",\n  "labels": {},\n  "createdat": "",\n  "modifiedat": "",\n  "envelope": "",\n  "protocol": "",\n  "messages": {}\n}' \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "messagegroupid": "",
  "name": "",
  "epoch": 0,
  "self": "",
  "xid": "",
  "description": "",
  "documentation": "",
  "labels": [],
  "createdat": "",
  "modifiedat": "",
  "envelope": "",
  "protocol": "",
  "messages": []
] as [String : Any]

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

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

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"

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

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"

	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/messagegroups/:groupid/messages/:resourceid/meta HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"))
    .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}}/messagegroups/:groupid/messages/:resourceid/meta")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")
  .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}}/messagegroups/:groupid/messages/:resourceid/meta');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta'
};

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta';
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}}/messagegroups/:groupid/messages/:resourceid/meta',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta');

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}}/messagegroups/:groupid/messages/:resourceid/meta'
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta';
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}}/messagegroups/:groupid/messages/:resourceid/meta"]
                                                       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}}/messagegroups/:groupid/messages/:resourceid/meta" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta",
  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}}/messagegroups/:groupid/messages/:resourceid/meta');

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/messagegroups/:groupid/messages/:resourceid/meta")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")

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/messagegroups/:groupid/messages/:resourceid/meta') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta";

    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}}/messagegroups/:groupid/messages/:resourceid/meta

http GET {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")! 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 patchMessagegroupMessageMeta

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta

BODY json

{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta");

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  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta" {:content-type :json
                                                                                              :form-params {:RESOURCEid ""
                                                                                                            :self ""
                                                                                                            :shortself ""
                                                                                                            :xid ""
                                                                                                            :xref ""
                                                                                                            :epoch 0
                                                                                                            :createdat ""
                                                                                                            :modifiedat ""
                                                                                                            :readonly false
                                                                                                            :compatibility ""
                                                                                                            :defaultversionid ""
                                                                                                            :defaultversionurl ""
                                                                                                            :defaultversionsticky false}})

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\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}}/messagegroups/:groupid/messages/:resourceid/meta"),
    Content = new StringContent("{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"

	payload := strings.NewReader("{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\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/messagegroups/:groupid/messages/:resourceid/meta HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 265

{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")
  .header("content-type", "application/json")
  .body("{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}")
  .asString();

const data = JSON.stringify({
  RESOURCEid: '',
  self: '',
  shortself: '',
  xid: '',
  xref: '',
  epoch: 0,
  createdat: '',
  modifiedat: '',
  readonly: false,
  compatibility: '',
  defaultversionid: '',
  defaultversionurl: '',
  defaultversionsticky: false
});

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

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

xhr.open('PATCH', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta',
  headers: {'content-type': 'application/json'},
  data: {
    RESOURCEid: '',
    self: '',
    shortself: '',
    xid: '',
    xref: '',
    epoch: 0,
    createdat: '',
    modifiedat: '',
    readonly: false,
    compatibility: '',
    defaultversionid: '',
    defaultversionurl: '',
    defaultversionsticky: false
  }
};

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"RESOURCEid":"","self":"","shortself":"","xid":"","xref":"","epoch":0,"createdat":"","modifiedat":"","readonly":false,"compatibility":"","defaultversionid":"","defaultversionurl":"","defaultversionsticky":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "RESOURCEid": "",\n  "self": "",\n  "shortself": "",\n  "xid": "",\n  "xref": "",\n  "epoch": 0,\n  "createdat": "",\n  "modifiedat": "",\n  "readonly": false,\n  "compatibility": "",\n  "defaultversionid": "",\n  "defaultversionurl": "",\n  "defaultversionsticky": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")
  .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/messagegroups/:groupid/messages/:resourceid/meta',
  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({
  RESOURCEid: '',
  self: '',
  shortself: '',
  xid: '',
  xref: '',
  epoch: 0,
  createdat: '',
  modifiedat: '',
  readonly: false,
  compatibility: '',
  defaultversionid: '',
  defaultversionurl: '',
  defaultversionsticky: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta',
  headers: {'content-type': 'application/json'},
  body: {
    RESOURCEid: '',
    self: '',
    shortself: '',
    xid: '',
    xref: '',
    epoch: 0,
    createdat: '',
    modifiedat: '',
    readonly: false,
    compatibility: '',
    defaultversionid: '',
    defaultversionurl: '',
    defaultversionsticky: false
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta');

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

req.type('json');
req.send({
  RESOURCEid: '',
  self: '',
  shortself: '',
  xid: '',
  xref: '',
  epoch: 0,
  createdat: '',
  modifiedat: '',
  readonly: false,
  compatibility: '',
  defaultversionid: '',
  defaultversionurl: '',
  defaultversionsticky: false
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta',
  headers: {'content-type': 'application/json'},
  data: {
    RESOURCEid: '',
    self: '',
    shortself: '',
    xid: '',
    xref: '',
    epoch: 0,
    createdat: '',
    modifiedat: '',
    readonly: false,
    compatibility: '',
    defaultversionid: '',
    defaultversionurl: '',
    defaultversionsticky: false
  }
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"RESOURCEid":"","self":"","shortself":"","xid":"","xref":"","epoch":0,"createdat":"","modifiedat":"","readonly":false,"compatibility":"","defaultversionid":"","defaultversionurl":"","defaultversionsticky":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"RESOURCEid": @"",
                              @"self": @"",
                              @"shortself": @"",
                              @"xid": @"",
                              @"xref": @"",
                              @"epoch": @0,
                              @"createdat": @"",
                              @"modifiedat": @"",
                              @"readonly": @NO,
                              @"compatibility": @"",
                              @"defaultversionid": @"",
                              @"defaultversionurl": @"",
                              @"defaultversionsticky": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"]
                                                       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}}/messagegroups/:groupid/messages/:resourceid/meta" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta",
  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([
    'RESOURCEid' => '',
    'self' => '',
    'shortself' => '',
    'xid' => '',
    'xref' => '',
    'epoch' => 0,
    'createdat' => '',
    'modifiedat' => '',
    'readonly' => null,
    'compatibility' => '',
    'defaultversionid' => '',
    'defaultversionurl' => '',
    'defaultversionsticky' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta', [
  'body' => '{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'RESOURCEid' => '',
  'self' => '',
  'shortself' => '',
  'xid' => '',
  'xref' => '',
  'epoch' => 0,
  'createdat' => '',
  'modifiedat' => '',
  'readonly' => null,
  'compatibility' => '',
  'defaultversionid' => '',
  'defaultversionurl' => '',
  'defaultversionsticky' => null
]));

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

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

append(json_encode([
  'RESOURCEid' => '',
  'self' => '',
  'shortself' => '',
  'xid' => '',
  'xref' => '',
  'epoch' => 0,
  'createdat' => '',
  'modifiedat' => '',
  'readonly' => null,
  'compatibility' => '',
  'defaultversionid' => '',
  'defaultversionurl' => '',
  'defaultversionsticky' => null
]));
$request->setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta');
$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}}/messagegroups/:groupid/messages/:resourceid/meta' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}'

import http.client

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

payload = "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}"

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

conn.request("PATCH", "/baseUrl/messagegroups/:groupid/messages/:resourceid/meta", payload, headers)

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"

payload = {
    "RESOURCEid": "",
    "self": "",
    "shortself": "",
    "xid": "",
    "xref": "",
    "epoch": 0,
    "createdat": "",
    "modifiedat": "",
    "readonly": False,
    "compatibility": "",
    "defaultversionid": "",
    "defaultversionurl": "",
    "defaultversionsticky": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"

payload <- "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\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}}/messagegroups/:groupid/messages/:resourceid/meta")

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  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/messagegroups/:groupid/messages/:resourceid/meta') do |req|
  req.body = "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\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}}/messagegroups/:groupid/messages/:resourceid/meta";

    let payload = json!({
        "RESOURCEid": "",
        "self": "",
        "shortself": "",
        "xid": "",
        "xref": "",
        "epoch": 0,
        "createdat": "",
        "modifiedat": "",
        "readonly": false,
        "compatibility": "",
        "defaultversionid": "",
        "defaultversionurl": "",
        "defaultversionsticky": false
    });

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

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

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta \
  --header 'content-type: application/json' \
  --data '{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}'

echo '{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}' |  \
  http PATCH {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "RESOURCEid": "",\n  "self": "",\n  "shortself": "",\n  "xid": "",\n  "xref": "",\n  "epoch": 0,\n  "createdat": "",\n  "modifiedat": "",\n  "readonly": false,\n  "compatibility": "",\n  "defaultversionid": "",\n  "defaultversionurl": "",\n  "defaultversionsticky": false\n}' \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")! 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 putMessagegroupMessageMeta

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta

BODY json

{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta");

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  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta" {:content-type :json
                                                                                            :form-params {:RESOURCEid ""
                                                                                                          :self ""
                                                                                                          :shortself ""
                                                                                                          :xid ""
                                                                                                          :xref ""
                                                                                                          :epoch 0
                                                                                                          :createdat ""
                                                                                                          :modifiedat ""
                                                                                                          :readonly false
                                                                                                          :compatibility ""
                                                                                                          :defaultversionid ""
                                                                                                          :defaultversionurl ""
                                                                                                          :defaultversionsticky false}})

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\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}}/messagegroups/:groupid/messages/:resourceid/meta"),
    Content = new StringContent("{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"

	payload := strings.NewReader("{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\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/messagegroups/:groupid/messages/:resourceid/meta HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 265

{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")
  .header("content-type", "application/json")
  .body("{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}")
  .asString();

const data = JSON.stringify({
  RESOURCEid: '',
  self: '',
  shortself: '',
  xid: '',
  xref: '',
  epoch: 0,
  createdat: '',
  modifiedat: '',
  readonly: false,
  compatibility: '',
  defaultversionid: '',
  defaultversionurl: '',
  defaultversionsticky: false
});

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

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

xhr.open('PUT', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta',
  headers: {'content-type': 'application/json'},
  data: {
    RESOURCEid: '',
    self: '',
    shortself: '',
    xid: '',
    xref: '',
    epoch: 0,
    createdat: '',
    modifiedat: '',
    readonly: false,
    compatibility: '',
    defaultversionid: '',
    defaultversionurl: '',
    defaultversionsticky: false
  }
};

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"RESOURCEid":"","self":"","shortself":"","xid":"","xref":"","epoch":0,"createdat":"","modifiedat":"","readonly":false,"compatibility":"","defaultversionid":"","defaultversionurl":"","defaultversionsticky":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "RESOURCEid": "",\n  "self": "",\n  "shortself": "",\n  "xid": "",\n  "xref": "",\n  "epoch": 0,\n  "createdat": "",\n  "modifiedat": "",\n  "readonly": false,\n  "compatibility": "",\n  "defaultversionid": "",\n  "defaultversionurl": "",\n  "defaultversionsticky": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")
  .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/messagegroups/:groupid/messages/:resourceid/meta',
  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({
  RESOURCEid: '',
  self: '',
  shortself: '',
  xid: '',
  xref: '',
  epoch: 0,
  createdat: '',
  modifiedat: '',
  readonly: false,
  compatibility: '',
  defaultversionid: '',
  defaultversionurl: '',
  defaultversionsticky: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta',
  headers: {'content-type': 'application/json'},
  body: {
    RESOURCEid: '',
    self: '',
    shortself: '',
    xid: '',
    xref: '',
    epoch: 0,
    createdat: '',
    modifiedat: '',
    readonly: false,
    compatibility: '',
    defaultversionid: '',
    defaultversionurl: '',
    defaultversionsticky: false
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta');

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

req.type('json');
req.send({
  RESOURCEid: '',
  self: '',
  shortself: '',
  xid: '',
  xref: '',
  epoch: 0,
  createdat: '',
  modifiedat: '',
  readonly: false,
  compatibility: '',
  defaultversionid: '',
  defaultversionurl: '',
  defaultversionsticky: false
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta',
  headers: {'content-type': 'application/json'},
  data: {
    RESOURCEid: '',
    self: '',
    shortself: '',
    xid: '',
    xref: '',
    epoch: 0,
    createdat: '',
    modifiedat: '',
    readonly: false,
    compatibility: '',
    defaultversionid: '',
    defaultversionurl: '',
    defaultversionsticky: false
  }
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"RESOURCEid":"","self":"","shortself":"","xid":"","xref":"","epoch":0,"createdat":"","modifiedat":"","readonly":false,"compatibility":"","defaultversionid":"","defaultversionurl":"","defaultversionsticky":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"RESOURCEid": @"",
                              @"self": @"",
                              @"shortself": @"",
                              @"xid": @"",
                              @"xref": @"",
                              @"epoch": @0,
                              @"createdat": @"",
                              @"modifiedat": @"",
                              @"readonly": @NO,
                              @"compatibility": @"",
                              @"defaultversionid": @"",
                              @"defaultversionurl": @"",
                              @"defaultversionsticky": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"]
                                                       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}}/messagegroups/:groupid/messages/:resourceid/meta" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta",
  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([
    'RESOURCEid' => '',
    'self' => '',
    'shortself' => '',
    'xid' => '',
    'xref' => '',
    'epoch' => 0,
    'createdat' => '',
    'modifiedat' => '',
    'readonly' => null,
    'compatibility' => '',
    'defaultversionid' => '',
    'defaultversionurl' => '',
    'defaultversionsticky' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta', [
  'body' => '{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'RESOURCEid' => '',
  'self' => '',
  'shortself' => '',
  'xid' => '',
  'xref' => '',
  'epoch' => 0,
  'createdat' => '',
  'modifiedat' => '',
  'readonly' => null,
  'compatibility' => '',
  'defaultversionid' => '',
  'defaultversionurl' => '',
  'defaultversionsticky' => null
]));

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

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

append(json_encode([
  'RESOURCEid' => '',
  'self' => '',
  'shortself' => '',
  'xid' => '',
  'xref' => '',
  'epoch' => 0,
  'createdat' => '',
  'modifiedat' => '',
  'readonly' => null,
  'compatibility' => '',
  'defaultversionid' => '',
  'defaultversionurl' => '',
  'defaultversionsticky' => null
]));
$request->setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta');
$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}}/messagegroups/:groupid/messages/:resourceid/meta' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}'

import http.client

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

payload = "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}"

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

conn.request("PUT", "/baseUrl/messagegroups/:groupid/messages/:resourceid/meta", payload, headers)

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"

payload = {
    "RESOURCEid": "",
    "self": "",
    "shortself": "",
    "xid": "",
    "xref": "",
    "epoch": 0,
    "createdat": "",
    "modifiedat": "",
    "readonly": False,
    "compatibility": "",
    "defaultversionid": "",
    "defaultversionurl": "",
    "defaultversionsticky": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta"

payload <- "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\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}}/messagegroups/:groupid/messages/:resourceid/meta")

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  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/messagegroups/:groupid/messages/:resourceid/meta') do |req|
  req.body = "{\n  \"RESOURCEid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"xref\": \"\",\n  \"epoch\": 0,\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"readonly\": false,\n  \"compatibility\": \"\",\n  \"defaultversionid\": \"\",\n  \"defaultversionurl\": \"\",\n  \"defaultversionsticky\": false\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}}/messagegroups/:groupid/messages/:resourceid/meta";

    let payload = json!({
        "RESOURCEid": "",
        "self": "",
        "shortself": "",
        "xid": "",
        "xref": "",
        "epoch": 0,
        "createdat": "",
        "modifiedat": "",
        "readonly": false,
        "compatibility": "",
        "defaultversionid": "",
        "defaultversionurl": "",
        "defaultversionsticky": false
    });

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta \
  --header 'content-type: application/json' \
  --data '{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}'

echo '{
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
}' |  \
  http PUT {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "RESOURCEid": "",\n  "self": "",\n  "shortself": "",\n  "xid": "",\n  "xref": "",\n  "epoch": 0,\n  "createdat": "",\n  "modifiedat": "",\n  "readonly": false,\n  "compatibility": "",\n  "defaultversionid": "",\n  "defaultversionurl": "",\n  "defaultversionsticky": false\n}' \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "RESOURCEid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "xref": "",
  "epoch": 0,
  "createdat": "",
  "modifiedat": "",
  "readonly": false,
  "compatibility": "",
  "defaultversionid": "",
  "defaultversionurl": "",
  "defaultversionsticky": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/meta")! 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 deleteMessagegroupMessageVersion

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid

QUERY PARAMS

epoch

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid" {:query-params {:epoch ""}})

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch="

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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch="

	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/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch="))
    .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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=")
  .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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid',
  params: {epoch: ''}
};

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=';
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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=',
  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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid',
  qs: {epoch: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid');

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

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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid',
  params: {epoch: ''}
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=';
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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch="]
                                                       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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=",
  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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=');

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'epoch' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid"

querystring = {"epoch":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid"

queryString <- list(epoch = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=")

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/messagegroups/:groupid/messages/:resourceid/versions/:versionid') do |req|
  req.params['epoch'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid";

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch='

http DELETE '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid?epoch=")! 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 getMessagegroupMessageVersion

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid")

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid"

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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid"

	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/messagegroups/:groupid/messages/:resourceid/versions/:versionid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid"))
    .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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid")
  .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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid'
};

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid';
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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid');

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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid'
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid';
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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid"]
                                                       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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid",
  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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid');

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/messagegroups/:groupid/messages/:resourceid/versions/:versionid")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid")

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/messagegroups/:groupid/messages/:resourceid/versions/:versionid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid";

    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}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid

http GET {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions/:versionid")! 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 postMessagegroupMessageVersions

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"

	payload := strings.NewReader("{}")

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

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

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

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

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

}

POST /baseUrl/messagegroups/:groupid/messages/:resourceid/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions")
  .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/messagegroups/:groupid/messages/:resourceid/versions',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"]
                                                       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}}/messagegroups/:groupid/messages/:resourceid/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions');
$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}}/messagegroups/:groupid/messages/:resourceid/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("POST", "/baseUrl/messagegroups/:groupid/messages/:resourceid/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"

payload <- "{}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{}"

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

require 'faraday'

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

response = conn.post('/baseUrl/messagegroups/:groupid/messages/:resourceid/versions') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions";

    let payload = json!({});

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions")! 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 getMessagegroupMessageVersionsAll

{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions")

require "http/client"

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"

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

var client = new RestClient("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"

	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/messagegroups/:groupid/messages/:resourceid/versions HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"))
    .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}}/messagegroups/:groupid/messages/:resourceid/versions")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions")
  .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}}/messagegroups/:groupid/messages/:resourceid/versions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions'
};

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions';
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}}/messagegroups/:groupid/messages/:resourceid/versions',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions');

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}}/messagegroups/:groupid/messages/:resourceid/versions'
};

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

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

const url = '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions';
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}}/messagegroups/:groupid/messages/:resourceid/versions"]
                                                       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}}/messagegroups/:groupid/messages/:resourceid/versions" in

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

 "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions",
  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}}/messagegroups/:groupid/messages/:resourceid/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/messagegroups/:groupid/messages/:resourceid/versions")

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

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

import requests

url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions")

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/messagegroups/:groupid/messages/:resourceid/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions";

    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}}/messagegroups/:groupid/messages/:resourceid/versions

http GET {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/messagegroups/:groupid/messages/:resourceid/versions")! 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 getRootDocument

{{baseUrl}}/

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

    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}}/

http GET {{baseUrl}}/

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

import Foundation

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

{{baseUrl}}/

BODY json

{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/" {:content-type :json
                                              :form-params {:specversion ""
                                                            :registryid ""
                                                            :self ""
                                                            :shortself ""
                                                            :xid ""
                                                            :epoch 0
                                                            :name ""
                                                            :description ""
                                                            :documentation ""
                                                            :labels {}
                                                            :createdat ""
                                                            :modifiedat ""
                                                            :capabilities {}
                                                            :model {}
                                                            :modelsource {}
                                                            :messagegroupsurl ""
                                                            :messagegroupscount 0
                                                            :messagegroups {}}})

require "http/client"

url = "{{baseUrl}}/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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}}/"),
    Content = new StringContent("{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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}}/");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/"

	payload := strings.NewReader("{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 350

{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/")
  .header("content-type", "application/json")
  .body("{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}")
  .asString();

const data = JSON.stringify({
  specversion: '',
  registryid: '',
  self: '',
  shortself: '',
  xid: '',
  epoch: 0,
  name: '',
  description: '',
  documentation: '',
  labels: {},
  createdat: '',
  modifiedat: '',
  capabilities: {},
  model: {},
  modelsource: {},
  messagegroupsurl: '',
  messagegroupscount: 0,
  messagegroups: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/',
  headers: {'content-type': 'application/json'},
  data: {
    specversion: '',
    registryid: '',
    self: '',
    shortself: '',
    xid: '',
    epoch: 0,
    name: '',
    description: '',
    documentation: '',
    labels: {},
    createdat: '',
    modifiedat: '',
    capabilities: {},
    model: {},
    modelsource: {},
    messagegroupsurl: '',
    messagegroupscount: 0,
    messagegroups: {}
  }
};

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

const url = '{{baseUrl}}/';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"specversion":"","registryid":"","self":"","shortself":"","xid":"","epoch":0,"name":"","description":"","documentation":"","labels":{},"createdat":"","modifiedat":"","capabilities":{},"model":{},"modelsource":{},"messagegroupsurl":"","messagegroupscount":0,"messagegroups":{}}'
};

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}}/',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "specversion": "",\n  "registryid": "",\n  "self": "",\n  "shortself": "",\n  "xid": "",\n  "epoch": 0,\n  "name": "",\n  "description": "",\n  "documentation": "",\n  "labels": {},\n  "createdat": "",\n  "modifiedat": "",\n  "capabilities": {},\n  "model": {},\n  "modelsource": {},\n  "messagegroupsurl": "",\n  "messagegroupscount": 0,\n  "messagegroups": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/")
  .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/',
  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({
  specversion: '',
  registryid: '',
  self: '',
  shortself: '',
  xid: '',
  epoch: 0,
  name: '',
  description: '',
  documentation: '',
  labels: {},
  createdat: '',
  modifiedat: '',
  capabilities: {},
  model: {},
  modelsource: {},
  messagegroupsurl: '',
  messagegroupscount: 0,
  messagegroups: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/',
  headers: {'content-type': 'application/json'},
  body: {
    specversion: '',
    registryid: '',
    self: '',
    shortself: '',
    xid: '',
    epoch: 0,
    name: '',
    description: '',
    documentation: '',
    labels: {},
    createdat: '',
    modifiedat: '',
    capabilities: {},
    model: {},
    modelsource: {},
    messagegroupsurl: '',
    messagegroupscount: 0,
    messagegroups: {}
  },
  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}}/');

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

req.type('json');
req.send({
  specversion: '',
  registryid: '',
  self: '',
  shortself: '',
  xid: '',
  epoch: 0,
  name: '',
  description: '',
  documentation: '',
  labels: {},
  createdat: '',
  modifiedat: '',
  capabilities: {},
  model: {},
  modelsource: {},
  messagegroupsurl: '',
  messagegroupscount: 0,
  messagegroups: {}
});

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}}/',
  headers: {'content-type': 'application/json'},
  data: {
    specversion: '',
    registryid: '',
    self: '',
    shortself: '',
    xid: '',
    epoch: 0,
    name: '',
    description: '',
    documentation: '',
    labels: {},
    createdat: '',
    modifiedat: '',
    capabilities: {},
    model: {},
    modelsource: {},
    messagegroupsurl: '',
    messagegroupscount: 0,
    messagegroups: {}
  }
};

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

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

const url = '{{baseUrl}}/';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"specversion":"","registryid":"","self":"","shortself":"","xid":"","epoch":0,"name":"","description":"","documentation":"","labels":{},"createdat":"","modifiedat":"","capabilities":{},"model":{},"modelsource":{},"messagegroupsurl":"","messagegroupscount":0,"messagegroups":{}}'
};

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 = @{ @"specversion": @"",
                              @"registryid": @"",
                              @"self": @"",
                              @"shortself": @"",
                              @"xid": @"",
                              @"epoch": @0,
                              @"name": @"",
                              @"description": @"",
                              @"documentation": @"",
                              @"labels": @{  },
                              @"createdat": @"",
                              @"modifiedat": @"",
                              @"capabilities": @{  },
                              @"model": @{  },
                              @"modelsource": @{  },
                              @"messagegroupsurl": @"",
                              @"messagegroupscount": @0,
                              @"messagegroups": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/"]
                                                       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}}/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}" in

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

 "{{baseUrl}}/",
  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([
    'specversion' => '',
    'registryid' => '',
    'self' => '',
    'shortself' => '',
    'xid' => '',
    'epoch' => 0,
    'name' => '',
    'description' => '',
    'documentation' => '',
    'labels' => [
        
    ],
    'createdat' => '',
    'modifiedat' => '',
    'capabilities' => [
        
    ],
    'model' => [
        
    ],
    'modelsource' => [
        
    ],
    'messagegroupsurl' => '',
    'messagegroupscount' => 0,
    'messagegroups' => [
        
    ]
  ]),
  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}}/', [
  'body' => '{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'specversion' => '',
  'registryid' => '',
  'self' => '',
  'shortself' => '',
  'xid' => '',
  'epoch' => 0,
  'name' => '',
  'description' => '',
  'documentation' => '',
  'labels' => [
    
  ],
  'createdat' => '',
  'modifiedat' => '',
  'capabilities' => [
    
  ],
  'model' => [
    
  ],
  'modelsource' => [
    
  ],
  'messagegroupsurl' => '',
  'messagegroupscount' => 0,
  'messagegroups' => [
    
  ]
]));

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

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

append(json_encode([
  'specversion' => '',
  'registryid' => '',
  'self' => '',
  'shortself' => '',
  'xid' => '',
  'epoch' => 0,
  'name' => '',
  'description' => '',
  'documentation' => '',
  'labels' => [
    
  ],
  'createdat' => '',
  'modifiedat' => '',
  'capabilities' => [
    
  ],
  'model' => [
    
  ],
  'modelsource' => [
    
  ],
  'messagegroupsurl' => '',
  'messagegroupscount' => 0,
  'messagegroups' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/');
$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}}/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}'

import http.client

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

payload = "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/"

payload = {
    "specversion": "",
    "registryid": "",
    "self": "",
    "shortself": "",
    "xid": "",
    "epoch": 0,
    "name": "",
    "description": "",
    "documentation": "",
    "labels": {},
    "createdat": "",
    "modifiedat": "",
    "capabilities": {},
    "model": {},
    "modelsource": {},
    "messagegroupsurl": "",
    "messagegroupscount": 0,
    "messagegroups": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/"

payload <- "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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}}/")

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  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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/') do |req|
  req.body = "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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}}/";

    let payload = json!({
        "specversion": "",
        "registryid": "",
        "self": "",
        "shortself": "",
        "xid": "",
        "epoch": 0,
        "name": "",
        "description": "",
        "documentation": "",
        "labels": json!({}),
        "createdat": "",
        "modifiedat": "",
        "capabilities": json!({}),
        "model": json!({}),
        "modelsource": json!({}),
        "messagegroupsurl": "",
        "messagegroupscount": 0,
        "messagegroups": json!({})
    });

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

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

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/ \
  --header 'content-type: application/json' \
  --data '{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}'

echo '{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}' |  \
  http PATCH {{baseUrl}}/ \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "specversion": "",\n  "registryid": "",\n  "self": "",\n  "shortself": "",\n  "xid": "",\n  "epoch": 0,\n  "name": "",\n  "description": "",\n  "documentation": "",\n  "labels": {},\n  "createdat": "",\n  "modifiedat": "",\n  "capabilities": {},\n  "model": {},\n  "modelsource": {},\n  "messagegroupsurl": "",\n  "messagegroupscount": 0,\n  "messagegroups": {}\n}' \
  --output-document \
  - {{baseUrl}}/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": [],
  "createdat": "",
  "modifiedat": "",
  "capabilities": [],
  "model": [],
  "modelsource": [],
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": []
] as [String : Any]

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

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

{{baseUrl}}/

BODY json

{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/" {:content-type :json
                                            :form-params {:specversion ""
                                                          :registryid ""
                                                          :self ""
                                                          :shortself ""
                                                          :xid ""
                                                          :epoch 0
                                                          :name ""
                                                          :description ""
                                                          :documentation ""
                                                          :labels {}
                                                          :createdat ""
                                                          :modifiedat ""
                                                          :capabilities {}
                                                          :model {}
                                                          :modelsource {}
                                                          :messagegroupsurl ""
                                                          :messagegroupscount 0
                                                          :messagegroups {}}})

require "http/client"

url = "{{baseUrl}}/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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}}/"),
    Content = new StringContent("{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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}}/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/"

	payload := strings.NewReader("{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 350

{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/")
  .header("content-type", "application/json")
  .body("{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}")
  .asString();

const data = JSON.stringify({
  specversion: '',
  registryid: '',
  self: '',
  shortself: '',
  xid: '',
  epoch: 0,
  name: '',
  description: '',
  documentation: '',
  labels: {},
  createdat: '',
  modifiedat: '',
  capabilities: {},
  model: {},
  modelsource: {},
  messagegroupsurl: '',
  messagegroupscount: 0,
  messagegroups: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/',
  headers: {'content-type': 'application/json'},
  data: {
    specversion: '',
    registryid: '',
    self: '',
    shortself: '',
    xid: '',
    epoch: 0,
    name: '',
    description: '',
    documentation: '',
    labels: {},
    createdat: '',
    modifiedat: '',
    capabilities: {},
    model: {},
    modelsource: {},
    messagegroupsurl: '',
    messagegroupscount: 0,
    messagegroups: {}
  }
};

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

const url = '{{baseUrl}}/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"specversion":"","registryid":"","self":"","shortself":"","xid":"","epoch":0,"name":"","description":"","documentation":"","labels":{},"createdat":"","modifiedat":"","capabilities":{},"model":{},"modelsource":{},"messagegroupsurl":"","messagegroupscount":0,"messagegroups":{}}'
};

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}}/',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "specversion": "",\n  "registryid": "",\n  "self": "",\n  "shortself": "",\n  "xid": "",\n  "epoch": 0,\n  "name": "",\n  "description": "",\n  "documentation": "",\n  "labels": {},\n  "createdat": "",\n  "modifiedat": "",\n  "capabilities": {},\n  "model": {},\n  "modelsource": {},\n  "messagegroupsurl": "",\n  "messagegroupscount": 0,\n  "messagegroups": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/")
  .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/',
  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({
  specversion: '',
  registryid: '',
  self: '',
  shortself: '',
  xid: '',
  epoch: 0,
  name: '',
  description: '',
  documentation: '',
  labels: {},
  createdat: '',
  modifiedat: '',
  capabilities: {},
  model: {},
  modelsource: {},
  messagegroupsurl: '',
  messagegroupscount: 0,
  messagegroups: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/',
  headers: {'content-type': 'application/json'},
  body: {
    specversion: '',
    registryid: '',
    self: '',
    shortself: '',
    xid: '',
    epoch: 0,
    name: '',
    description: '',
    documentation: '',
    labels: {},
    createdat: '',
    modifiedat: '',
    capabilities: {},
    model: {},
    modelsource: {},
    messagegroupsurl: '',
    messagegroupscount: 0,
    messagegroups: {}
  },
  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}}/');

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

req.type('json');
req.send({
  specversion: '',
  registryid: '',
  self: '',
  shortself: '',
  xid: '',
  epoch: 0,
  name: '',
  description: '',
  documentation: '',
  labels: {},
  createdat: '',
  modifiedat: '',
  capabilities: {},
  model: {},
  modelsource: {},
  messagegroupsurl: '',
  messagegroupscount: 0,
  messagegroups: {}
});

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}}/',
  headers: {'content-type': 'application/json'},
  data: {
    specversion: '',
    registryid: '',
    self: '',
    shortself: '',
    xid: '',
    epoch: 0,
    name: '',
    description: '',
    documentation: '',
    labels: {},
    createdat: '',
    modifiedat: '',
    capabilities: {},
    model: {},
    modelsource: {},
    messagegroupsurl: '',
    messagegroupscount: 0,
    messagegroups: {}
  }
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"specversion":"","registryid":"","self":"","shortself":"","xid":"","epoch":0,"name":"","description":"","documentation":"","labels":{},"createdat":"","modifiedat":"","capabilities":{},"model":{},"modelsource":{},"messagegroupsurl":"","messagegroupscount":0,"messagegroups":{}}'
};

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 = @{ @"specversion": @"",
                              @"registryid": @"",
                              @"self": @"",
                              @"shortself": @"",
                              @"xid": @"",
                              @"epoch": @0,
                              @"name": @"",
                              @"description": @"",
                              @"documentation": @"",
                              @"labels": @{  },
                              @"createdat": @"",
                              @"modifiedat": @"",
                              @"capabilities": @{  },
                              @"model": @{  },
                              @"modelsource": @{  },
                              @"messagegroupsurl": @"",
                              @"messagegroupscount": @0,
                              @"messagegroups": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/"]
                                                       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}}/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/",
  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([
    'specversion' => '',
    'registryid' => '',
    'self' => '',
    'shortself' => '',
    'xid' => '',
    'epoch' => 0,
    'name' => '',
    'description' => '',
    'documentation' => '',
    'labels' => [
        
    ],
    'createdat' => '',
    'modifiedat' => '',
    'capabilities' => [
        
    ],
    'model' => [
        
    ],
    'modelsource' => [
        
    ],
    'messagegroupsurl' => '',
    'messagegroupscount' => 0,
    'messagegroups' => [
        
    ]
  ]),
  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}}/', [
  'body' => '{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'specversion' => '',
  'registryid' => '',
  'self' => '',
  'shortself' => '',
  'xid' => '',
  'epoch' => 0,
  'name' => '',
  'description' => '',
  'documentation' => '',
  'labels' => [
    
  ],
  'createdat' => '',
  'modifiedat' => '',
  'capabilities' => [
    
  ],
  'model' => [
    
  ],
  'modelsource' => [
    
  ],
  'messagegroupsurl' => '',
  'messagegroupscount' => 0,
  'messagegroups' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'specversion' => '',
  'registryid' => '',
  'self' => '',
  'shortself' => '',
  'xid' => '',
  'epoch' => 0,
  'name' => '',
  'description' => '',
  'documentation' => '',
  'labels' => [
    
  ],
  'createdat' => '',
  'modifiedat' => '',
  'capabilities' => [
    
  ],
  'model' => [
    
  ],
  'modelsource' => [
    
  ],
  'messagegroupsurl' => '',
  'messagegroupscount' => 0,
  'messagegroups' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/');
$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}}/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/"

payload = {
    "specversion": "",
    "registryid": "",
    "self": "",
    "shortself": "",
    "xid": "",
    "epoch": 0,
    "name": "",
    "description": "",
    "documentation": "",
    "labels": {},
    "createdat": "",
    "modifiedat": "",
    "capabilities": {},
    "model": {},
    "modelsource": {},
    "messagegroupsurl": "",
    "messagegroupscount": 0,
    "messagegroups": {}
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/"

payload <- "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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}}/")

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  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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/') do |req|
  req.body = "{\n  \"specversion\": \"\",\n  \"registryid\": \"\",\n  \"self\": \"\",\n  \"shortself\": \"\",\n  \"xid\": \"\",\n  \"epoch\": 0,\n  \"name\": \"\",\n  \"description\": \"\",\n  \"documentation\": \"\",\n  \"labels\": {},\n  \"createdat\": \"\",\n  \"modifiedat\": \"\",\n  \"capabilities\": {},\n  \"model\": {},\n  \"modelsource\": {},\n  \"messagegroupsurl\": \"\",\n  \"messagegroupscount\": 0,\n  \"messagegroups\": {}\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}}/";

    let payload = json!({
        "specversion": "",
        "registryid": "",
        "self": "",
        "shortself": "",
        "xid": "",
        "epoch": 0,
        "name": "",
        "description": "",
        "documentation": "",
        "labels": json!({}),
        "createdat": "",
        "modifiedat": "",
        "capabilities": json!({}),
        "model": json!({}),
        "modelsource": json!({}),
        "messagegroupsurl": "",
        "messagegroupscount": 0,
        "messagegroups": json!({})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/ \
  --header 'content-type: application/json' \
  --data '{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}'

echo '{
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": {},
  "createdat": "",
  "modifiedat": "",
  "capabilities": {},
  "model": {},
  "modelsource": {},
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": {}
}' |  \
  http PUT {{baseUrl}}/ \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "specversion": "",\n  "registryid": "",\n  "self": "",\n  "shortself": "",\n  "xid": "",\n  "epoch": 0,\n  "name": "",\n  "description": "",\n  "documentation": "",\n  "labels": {},\n  "createdat": "",\n  "modifiedat": "",\n  "capabilities": {},\n  "model": {},\n  "modelsource": {},\n  "messagegroupsurl": "",\n  "messagegroupscount": 0,\n  "messagegroups": {}\n}' \
  --output-document \
  - {{baseUrl}}/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "specversion": "",
  "registryid": "",
  "self": "",
  "shortself": "",
  "xid": "",
  "epoch": 0,
  "name": "",
  "description": "",
  "documentation": "",
  "labels": [],
  "createdat": "",
  "modifiedat": "",
  "capabilities": [],
  "model": [],
  "modelsource": [],
  "messagegroupsurl": "",
  "messagegroupscount": 0,
  "messagegroups": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/")! 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()