Amazon API Gateway

POST CreateApiKey

{{baseUrl}}/apikeys

BODY json

{
  "name": "",
  "description": "",
  "enabled": false,
  "generateDistinctId": false,
  "value": "",
  "stageKeys": [
    {
      "restApiId": "",
      "stageName": ""
    }
  ],
  "customerId": "",
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/apikeys" {:content-type :json
                                                    :form-params {:name ""
                                                                  :description ""
                                                                  :enabled false
                                                                  :generateDistinctId false
                                                                  :value ""
                                                                  :stageKeys [{:restApiId ""
                                                                               :stageName ""}]
                                                                  :customerId ""
                                                                  :tags {}}})

require "http/client"

url = "{{baseUrl}}/apikeys"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/apikeys"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\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}}/apikeys");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}")

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

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

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

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

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

}

POST /baseUrl/apikeys HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 216

{
  "name": "",
  "description": "",
  "enabled": false,
  "generateDistinctId": false,
  "value": "",
  "stageKeys": [
    {
      "restApiId": "",
      "stageName": ""
    }
  ],
  "customerId": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/apikeys")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/apikeys"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\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  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/apikeys")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/apikeys")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  description: '',
  enabled: false,
  generateDistinctId: false,
  value: '',
  stageKeys: [
    {
      restApiId: '',
      stageName: ''
    }
  ],
  customerId: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/apikeys',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    description: '',
    enabled: false,
    generateDistinctId: false,
    value: '',
    stageKeys: [{restApiId: '', stageName: ''}],
    customerId: '',
    tags: {}
  }
};

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

const url = '{{baseUrl}}/apikeys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","description":"","enabled":false,"generateDistinctId":false,"value":"","stageKeys":[{"restApiId":"","stageName":""}],"customerId":"","tags":{}}'
};

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}}/apikeys',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "description": "",\n  "enabled": false,\n  "generateDistinctId": false,\n  "value": "",\n  "stageKeys": [\n    {\n      "restApiId": "",\n      "stageName": ""\n    }\n  ],\n  "customerId": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/apikeys")
  .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/apikeys',
  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({
  name: '',
  description: '',
  enabled: false,
  generateDistinctId: false,
  value: '',
  stageKeys: [{restApiId: '', stageName: ''}],
  customerId: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/apikeys',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    description: '',
    enabled: false,
    generateDistinctId: false,
    value: '',
    stageKeys: [{restApiId: '', stageName: ''}],
    customerId: '',
    tags: {}
  },
  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}}/apikeys');

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

req.type('json');
req.send({
  name: '',
  description: '',
  enabled: false,
  generateDistinctId: false,
  value: '',
  stageKeys: [
    {
      restApiId: '',
      stageName: ''
    }
  ],
  customerId: '',
  tags: {}
});

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}}/apikeys',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    description: '',
    enabled: false,
    generateDistinctId: false,
    value: '',
    stageKeys: [{restApiId: '', stageName: ''}],
    customerId: '',
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/apikeys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","description":"","enabled":false,"generateDistinctId":false,"value":"","stageKeys":[{"restApiId":"","stageName":""}],"customerId":"","tags":{}}'
};

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 = @{ @"name": @"",
                              @"description": @"",
                              @"enabled": @NO,
                              @"generateDistinctId": @NO,
                              @"value": @"",
                              @"stageKeys": @[ @{ @"restApiId": @"", @"stageName": @"" } ],
                              @"customerId": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/apikeys"]
                                                       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}}/apikeys" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/apikeys",
  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([
    'name' => '',
    'description' => '',
    'enabled' => null,
    'generateDistinctId' => null,
    'value' => '',
    'stageKeys' => [
        [
                'restApiId' => '',
                'stageName' => ''
        ]
    ],
    'customerId' => '',
    'tags' => [
        
    ]
  ]),
  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}}/apikeys', [
  'body' => '{
  "name": "",
  "description": "",
  "enabled": false,
  "generateDistinctId": false,
  "value": "",
  "stageKeys": [
    {
      "restApiId": "",
      "stageName": ""
    }
  ],
  "customerId": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'description' => '',
  'enabled' => null,
  'generateDistinctId' => null,
  'value' => '',
  'stageKeys' => [
    [
        'restApiId' => '',
        'stageName' => ''
    ]
  ],
  'customerId' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'name' => '',
  'description' => '',
  'enabled' => null,
  'generateDistinctId' => null,
  'value' => '',
  'stageKeys' => [
    [
        'restApiId' => '',
        'stageName' => ''
    ]
  ],
  'customerId' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/apikeys');
$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}}/apikeys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "description": "",
  "enabled": false,
  "generateDistinctId": false,
  "value": "",
  "stageKeys": [
    {
      "restApiId": "",
      "stageName": ""
    }
  ],
  "customerId": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/apikeys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "description": "",
  "enabled": false,
  "generateDistinctId": false,
  "value": "",
  "stageKeys": [
    {
      "restApiId": "",
      "stageName": ""
    }
  ],
  "customerId": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/apikeys"

payload = {
    "name": "",
    "description": "",
    "enabled": False,
    "generateDistinctId": False,
    "value": "",
    "stageKeys": [
        {
            "restApiId": "",
            "stageName": ""
        }
    ],
    "customerId": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/apikeys') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"enabled\": false,\n  \"generateDistinctId\": false,\n  \"value\": \"\",\n  \"stageKeys\": [\n    {\n      \"restApiId\": \"\",\n      \"stageName\": \"\"\n    }\n  ],\n  \"customerId\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "name": "",
        "description": "",
        "enabled": false,
        "generateDistinctId": false,
        "value": "",
        "stageKeys": (
            json!({
                "restApiId": "",
                "stageName": ""
            })
        ),
        "customerId": "",
        "tags": 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}}/apikeys \
  --header 'content-type: application/json' \
  --data '{
  "name": "",
  "description": "",
  "enabled": false,
  "generateDistinctId": false,
  "value": "",
  "stageKeys": [
    {
      "restApiId": "",
      "stageName": ""
    }
  ],
  "customerId": "",
  "tags": {}
}'

echo '{
  "name": "",
  "description": "",
  "enabled": false,
  "generateDistinctId": false,
  "value": "",
  "stageKeys": [
    {
      "restApiId": "",
      "stageName": ""
    }
  ],
  "customerId": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/apikeys \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "description": "",\n  "enabled": false,\n  "generateDistinctId": false,\n  "value": "",\n  "stageKeys": [\n    {\n      "restApiId": "",\n      "stageName": ""\n    }\n  ],\n  "customerId": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/apikeys

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "description": "",
  "enabled": false,
  "generateDistinctId": false,
  "value": "",
  "stageKeys": [
    [
      "restApiId": "",
      "stageName": ""
    ]
  ],
  "customerId": "",
  "tags": []
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateAuthorizer

{{baseUrl}}/restapis/:restapi_id/authorizers

QUERY PARAMS

restapi_id

BODY json

{
  "name": "",
  "type": "",
  "providerARNs": [],
  "authType": "",
  "authorizerUri": "",
  "authorizerCredentials": "",
  "identitySource": "",
  "identityValidationExpression": "",
  "authorizerResultTtlInSeconds": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/authorizers");

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  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/restapis/:restapi_id/authorizers" {:content-type :json
                                                                             :form-params {:name ""
                                                                                           :type ""
                                                                                           :providerARNs []
                                                                                           :authType ""
                                                                                           :authorizerUri ""
                                                                                           :authorizerCredentials ""
                                                                                           :identitySource ""
                                                                                           :identityValidationExpression ""
                                                                                           :authorizerResultTtlInSeconds 0}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/authorizers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/authorizers"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\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}}/restapis/:restapi_id/authorizers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/authorizers"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}")

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

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

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

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

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

}

POST /baseUrl/restapis/:restapi_id/authorizers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 223

{
  "name": "",
  "type": "",
  "providerARNs": [],
  "authType": "",
  "authorizerUri": "",
  "authorizerCredentials": "",
  "identitySource": "",
  "identityValidationExpression": "",
  "authorizerResultTtlInSeconds": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis/:restapi_id/authorizers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/authorizers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\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  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/authorizers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/restapis/:restapi_id/authorizers")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  type: '',
  providerARNs: [],
  authType: '',
  authorizerUri: '',
  authorizerCredentials: '',
  identitySource: '',
  identityValidationExpression: '',
  authorizerResultTtlInSeconds: 0
});

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

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

xhr.open('POST', '{{baseUrl}}/restapis/:restapi_id/authorizers');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    type: '',
    providerARNs: [],
    authType: '',
    authorizerUri: '',
    authorizerCredentials: '',
    identitySource: '',
    identityValidationExpression: '',
    authorizerResultTtlInSeconds: 0
  }
};

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

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","type":"","providerARNs":[],"authType":"","authorizerUri":"","authorizerCredentials":"","identitySource":"","identityValidationExpression":"","authorizerResultTtlInSeconds":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "type": "",\n  "providerARNs": [],\n  "authType": "",\n  "authorizerUri": "",\n  "authorizerCredentials": "",\n  "identitySource": "",\n  "identityValidationExpression": "",\n  "authorizerResultTtlInSeconds": 0\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/authorizers")
  .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/restapis/:restapi_id/authorizers',
  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({
  name: '',
  type: '',
  providerARNs: [],
  authType: '',
  authorizerUri: '',
  authorizerCredentials: '',
  identitySource: '',
  identityValidationExpression: '',
  authorizerResultTtlInSeconds: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    type: '',
    providerARNs: [],
    authType: '',
    authorizerUri: '',
    authorizerCredentials: '',
    identitySource: '',
    identityValidationExpression: '',
    authorizerResultTtlInSeconds: 0
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restapis/:restapi_id/authorizers');

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

req.type('json');
req.send({
  name: '',
  type: '',
  providerARNs: [],
  authType: '',
  authorizerUri: '',
  authorizerCredentials: '',
  identitySource: '',
  identityValidationExpression: '',
  authorizerResultTtlInSeconds: 0
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    type: '',
    providerARNs: [],
    authType: '',
    authorizerUri: '',
    authorizerCredentials: '',
    identitySource: '',
    identityValidationExpression: '',
    authorizerResultTtlInSeconds: 0
  }
};

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

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

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","type":"","providerARNs":[],"authType":"","authorizerUri":"","authorizerCredentials":"","identitySource":"","identityValidationExpression":"","authorizerResultTtlInSeconds":0}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"type": @"",
                              @"providerARNs": @[  ],
                              @"authType": @"",
                              @"authorizerUri": @"",
                              @"authorizerCredentials": @"",
                              @"identitySource": @"",
                              @"identityValidationExpression": @"",
                              @"authorizerResultTtlInSeconds": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/authorizers"]
                                                       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}}/restapis/:restapi_id/authorizers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}" in

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

 "{{baseUrl}}/restapis/:restapi_id/authorizers",
  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([
    'name' => '',
    'type' => '',
    'providerARNs' => [
        
    ],
    'authType' => '',
    'authorizerUri' => '',
    'authorizerCredentials' => '',
    'identitySource' => '',
    'identityValidationExpression' => '',
    'authorizerResultTtlInSeconds' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/restapis/:restapi_id/authorizers', [
  'body' => '{
  "name": "",
  "type": "",
  "providerARNs": [],
  "authType": "",
  "authorizerUri": "",
  "authorizerCredentials": "",
  "identitySource": "",
  "identityValidationExpression": "",
  "authorizerResultTtlInSeconds": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/authorizers');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'type' => '',
  'providerARNs' => [
    
  ],
  'authType' => '',
  'authorizerUri' => '',
  'authorizerCredentials' => '',
  'identitySource' => '',
  'identityValidationExpression' => '',
  'authorizerResultTtlInSeconds' => 0
]));

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

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

append(json_encode([
  'name' => '',
  'type' => '',
  'providerARNs' => [
    
  ],
  'authType' => '',
  'authorizerUri' => '',
  'authorizerCredentials' => '',
  'identitySource' => '',
  'identityValidationExpression' => '',
  'authorizerResultTtlInSeconds' => 0
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/authorizers');
$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}}/restapis/:restapi_id/authorizers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "type": "",
  "providerARNs": [],
  "authType": "",
  "authorizerUri": "",
  "authorizerCredentials": "",
  "identitySource": "",
  "identityValidationExpression": "",
  "authorizerResultTtlInSeconds": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/authorizers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "type": "",
  "providerARNs": [],
  "authType": "",
  "authorizerUri": "",
  "authorizerCredentials": "",
  "identitySource": "",
  "identityValidationExpression": "",
  "authorizerResultTtlInSeconds": 0
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}"

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

conn.request("POST", "/baseUrl/restapis/:restapi_id/authorizers", payload, headers)

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

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

import requests

url = "{{baseUrl}}/restapis/:restapi_id/authorizers"

payload = {
    "name": "",
    "type": "",
    "providerARNs": [],
    "authType": "",
    "authorizerUri": "",
    "authorizerCredentials": "",
    "identitySource": "",
    "identityValidationExpression": "",
    "authorizerResultTtlInSeconds": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/authorizers"

payload <- "{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/authorizers")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/restapis/:restapi_id/authorizers') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"type\": \"\",\n  \"providerARNs\": [],\n  \"authType\": \"\",\n  \"authorizerUri\": \"\",\n  \"authorizerCredentials\": \"\",\n  \"identitySource\": \"\",\n  \"identityValidationExpression\": \"\",\n  \"authorizerResultTtlInSeconds\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "name": "",
        "type": "",
        "providerARNs": (),
        "authType": "",
        "authorizerUri": "",
        "authorizerCredentials": "",
        "identitySource": "",
        "identityValidationExpression": "",
        "authorizerResultTtlInSeconds": 0
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/restapis/:restapi_id/authorizers \
  --header 'content-type: application/json' \
  --data '{
  "name": "",
  "type": "",
  "providerARNs": [],
  "authType": "",
  "authorizerUri": "",
  "authorizerCredentials": "",
  "identitySource": "",
  "identityValidationExpression": "",
  "authorizerResultTtlInSeconds": 0
}'

echo '{
  "name": "",
  "type": "",
  "providerARNs": [],
  "authType": "",
  "authorizerUri": "",
  "authorizerCredentials": "",
  "identitySource": "",
  "identityValidationExpression": "",
  "authorizerResultTtlInSeconds": 0
}' |  \
  http POST {{baseUrl}}/restapis/:restapi_id/authorizers \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "type": "",\n  "providerARNs": [],\n  "authType": "",\n  "authorizerUri": "",\n  "authorizerCredentials": "",\n  "identitySource": "",\n  "identityValidationExpression": "",\n  "authorizerResultTtlInSeconds": 0\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/authorizers

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "type": "",
  "providerARNs": [],
  "authType": "",
  "authorizerUri": "",
  "authorizerCredentials": "",
  "identitySource": "",
  "identityValidationExpression": "",
  "authorizerResultTtlInSeconds": 0
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateBasePathMapping

{{baseUrl}}/domainnames/:domain_name/basepathmappings

QUERY PARAMS

domain_name

BODY json

{
  "basePath": "",
  "restApiId": "",
  "stage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domainnames/:domain_name/basepathmappings");

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  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domainnames/:domain_name/basepathmappings" {:content-type :json
                                                                                      :form-params {:basePath ""
                                                                                                    :restApiId ""
                                                                                                    :stage ""}})

require "http/client"

url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/domainnames/:domain_name/basepathmappings"),
    Content = new StringContent("{\n  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\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}}/domainnames/:domain_name/basepathmappings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domainnames/:domain_name/basepathmappings"

	payload := strings.NewReader("{\n  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/domainnames/:domain_name/basepathmappings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "basePath": "",
  "restApiId": "",
  "stage": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domainnames/:domain_name/basepathmappings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/domainnames/:domain_name/basepathmappings")
  .header("content-type", "application/json")
  .body("{\n  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  basePath: '',
  restApiId: '',
  stage: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/domainnames/:domain_name/basepathmappings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings',
  headers: {'content-type': 'application/json'},
  data: {basePath: '', restApiId: '', stage: ''}
};

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

const url = '{{baseUrl}}/domainnames/:domain_name/basepathmappings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"basePath":"","restApiId":"","stage":""}'
};

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}}/domainnames/:domain_name/basepathmappings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "basePath": "",\n  "restApiId": "",\n  "stage": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name/basepathmappings")
  .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/domainnames/:domain_name/basepathmappings',
  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({basePath: '', restApiId: '', stage: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings',
  headers: {'content-type': 'application/json'},
  body: {basePath: '', restApiId: '', stage: ''},
  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}}/domainnames/:domain_name/basepathmappings');

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

req.type('json');
req.send({
  basePath: '',
  restApiId: '',
  stage: ''
});

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}}/domainnames/:domain_name/basepathmappings',
  headers: {'content-type': 'application/json'},
  data: {basePath: '', restApiId: '', stage: ''}
};

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

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

const url = '{{baseUrl}}/domainnames/:domain_name/basepathmappings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"basePath":"","restApiId":"","stage":""}'
};

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 = @{ @"basePath": @"",
                              @"restApiId": @"",
                              @"stage": @"" };

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

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

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

 "{{baseUrl}}/domainnames/:domain_name/basepathmappings",
  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([
    'basePath' => '',
    'restApiId' => '',
    'stage' => ''
  ]),
  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}}/domainnames/:domain_name/basepathmappings', [
  'body' => '{
  "basePath": "",
  "restApiId": "",
  "stage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domainnames/:domain_name/basepathmappings');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'basePath' => '',
  'restApiId' => '',
  'stage' => ''
]));

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

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

append(json_encode([
  'basePath' => '',
  'restApiId' => '',
  'stage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domainnames/:domain_name/basepathmappings');
$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}}/domainnames/:domain_name/basepathmappings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "basePath": "",
  "restApiId": "",
  "stage": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainnames/:domain_name/basepathmappings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "basePath": "",
  "restApiId": "",
  "stage": ""
}'

import http.client

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

payload = "{\n  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\n}"

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

conn.request("POST", "/baseUrl/domainnames/:domain_name/basepathmappings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings"

payload = {
    "basePath": "",
    "restApiId": "",
    "stage": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domainnames/:domain_name/basepathmappings"

payload <- "{\n  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domainnames/:domain_name/basepathmappings")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/domainnames/:domain_name/basepathmappings') do |req|
  req.body = "{\n  \"basePath\": \"\",\n  \"restApiId\": \"\",\n  \"stage\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "basePath": "",
        "restApiId": "",
        "stage": ""
    });

    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}}/domainnames/:domain_name/basepathmappings \
  --header 'content-type: application/json' \
  --data '{
  "basePath": "",
  "restApiId": "",
  "stage": ""
}'

echo '{
  "basePath": "",
  "restApiId": "",
  "stage": ""
}' |  \
  http POST {{baseUrl}}/domainnames/:domain_name/basepathmappings \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "basePath": "",\n  "restApiId": "",\n  "stage": ""\n}' \
  --output-document \
  - {{baseUrl}}/domainnames/:domain_name/basepathmappings

import Foundation

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

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

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

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

dataTask.resume()

POST CreateDeployment

{{baseUrl}}/restapis/:restapi_id/deployments

QUERY PARAMS

restapi_id

BODY json

{
  "stageName": "",
  "stageDescription": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "canarySettings": {
    "percentTraffic": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/deployments");

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  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/restapis/:restapi_id/deployments" {:content-type :json
                                                                             :form-params {:stageName ""
                                                                                           :stageDescription ""
                                                                                           :description ""
                                                                                           :cacheClusterEnabled false
                                                                                           :cacheClusterSize ""
                                                                                           :variables {}
                                                                                           :canarySettings {:percentTraffic ""
                                                                                                            :stageVariableOverrides ""
                                                                                                            :useStageCache ""}
                                                                                           :tracingEnabled false}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/deployments"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/deployments"),
    Content = new StringContent("{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": 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}}/restapis/:restapi_id/deployments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/deployments"

	payload := strings.NewReader("{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}")

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

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

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

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

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

}

POST /baseUrl/restapis/:restapi_id/deployments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 283

{
  "stageName": "",
  "stageDescription": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "canarySettings": {
    "percentTraffic": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis/:restapi_id/deployments")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/deployments"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": 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  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/deployments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/restapis/:restapi_id/deployments")
  .header("content-type", "application/json")
  .body("{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}")
  .asString();

const data = JSON.stringify({
  stageName: '',
  stageDescription: '',
  description: '',
  cacheClusterEnabled: false,
  cacheClusterSize: '',
  variables: {},
  canarySettings: {
    percentTraffic: '',
    stageVariableOverrides: '',
    useStageCache: ''
  },
  tracingEnabled: false
});

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

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

xhr.open('POST', '{{baseUrl}}/restapis/:restapi_id/deployments');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments',
  headers: {'content-type': 'application/json'},
  data: {
    stageName: '',
    stageDescription: '',
    description: '',
    cacheClusterEnabled: false,
    cacheClusterSize: '',
    variables: {},
    canarySettings: {percentTraffic: '', stageVariableOverrides: '', useStageCache: ''},
    tracingEnabled: false
  }
};

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

const url = '{{baseUrl}}/restapis/:restapi_id/deployments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"stageName":"","stageDescription":"","description":"","cacheClusterEnabled":false,"cacheClusterSize":"","variables":{},"canarySettings":{"percentTraffic":"","stageVariableOverrides":"","useStageCache":""},"tracingEnabled":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}}/restapis/:restapi_id/deployments',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "stageName": "",\n  "stageDescription": "",\n  "description": "",\n  "cacheClusterEnabled": false,\n  "cacheClusterSize": "",\n  "variables": {},\n  "canarySettings": {\n    "percentTraffic": "",\n    "stageVariableOverrides": "",\n    "useStageCache": ""\n  },\n  "tracingEnabled": 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  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/deployments")
  .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/restapis/:restapi_id/deployments',
  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({
  stageName: '',
  stageDescription: '',
  description: '',
  cacheClusterEnabled: false,
  cacheClusterSize: '',
  variables: {},
  canarySettings: {percentTraffic: '', stageVariableOverrides: '', useStageCache: ''},
  tracingEnabled: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments',
  headers: {'content-type': 'application/json'},
  body: {
    stageName: '',
    stageDescription: '',
    description: '',
    cacheClusterEnabled: false,
    cacheClusterSize: '',
    variables: {},
    canarySettings: {percentTraffic: '', stageVariableOverrides: '', useStageCache: ''},
    tracingEnabled: false
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restapis/:restapi_id/deployments');

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

req.type('json');
req.send({
  stageName: '',
  stageDescription: '',
  description: '',
  cacheClusterEnabled: false,
  cacheClusterSize: '',
  variables: {},
  canarySettings: {
    percentTraffic: '',
    stageVariableOverrides: '',
    useStageCache: ''
  },
  tracingEnabled: false
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments',
  headers: {'content-type': 'application/json'},
  data: {
    stageName: '',
    stageDescription: '',
    description: '',
    cacheClusterEnabled: false,
    cacheClusterSize: '',
    variables: {},
    canarySettings: {percentTraffic: '', stageVariableOverrides: '', useStageCache: ''},
    tracingEnabled: false
  }
};

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

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

const url = '{{baseUrl}}/restapis/:restapi_id/deployments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"stageName":"","stageDescription":"","description":"","cacheClusterEnabled":false,"cacheClusterSize":"","variables":{},"canarySettings":{"percentTraffic":"","stageVariableOverrides":"","useStageCache":""},"tracingEnabled":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 = @{ @"stageName": @"",
                              @"stageDescription": @"",
                              @"description": @"",
                              @"cacheClusterEnabled": @NO,
                              @"cacheClusterSize": @"",
                              @"variables": @{  },
                              @"canarySettings": @{ @"percentTraffic": @"", @"stageVariableOverrides": @"", @"useStageCache": @"" },
                              @"tracingEnabled": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/deployments"]
                                                       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}}/restapis/:restapi_id/deployments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}" in

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

 "{{baseUrl}}/restapis/:restapi_id/deployments",
  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([
    'stageName' => '',
    'stageDescription' => '',
    'description' => '',
    'cacheClusterEnabled' => null,
    'cacheClusterSize' => '',
    'variables' => [
        
    ],
    'canarySettings' => [
        'percentTraffic' => '',
        'stageVariableOverrides' => '',
        'useStageCache' => ''
    ],
    'tracingEnabled' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/restapis/:restapi_id/deployments', [
  'body' => '{
  "stageName": "",
  "stageDescription": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "canarySettings": {
    "percentTraffic": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/deployments');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'stageName' => '',
  'stageDescription' => '',
  'description' => '',
  'cacheClusterEnabled' => null,
  'cacheClusterSize' => '',
  'variables' => [
    
  ],
  'canarySettings' => [
    'percentTraffic' => '',
    'stageVariableOverrides' => '',
    'useStageCache' => ''
  ],
  'tracingEnabled' => null
]));

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

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

append(json_encode([
  'stageName' => '',
  'stageDescription' => '',
  'description' => '',
  'cacheClusterEnabled' => null,
  'cacheClusterSize' => '',
  'variables' => [
    
  ],
  'canarySettings' => [
    'percentTraffic' => '',
    'stageVariableOverrides' => '',
    'useStageCache' => ''
  ],
  'tracingEnabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/deployments');
$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}}/restapis/:restapi_id/deployments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "stageName": "",
  "stageDescription": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "canarySettings": {
    "percentTraffic": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/deployments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "stageName": "",
  "stageDescription": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "canarySettings": {
    "percentTraffic": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false
}'

import http.client

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

payload = "{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}"

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

conn.request("POST", "/baseUrl/restapis/:restapi_id/deployments", payload, headers)

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

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

import requests

url = "{{baseUrl}}/restapis/:restapi_id/deployments"

payload = {
    "stageName": "",
    "stageDescription": "",
    "description": "",
    "cacheClusterEnabled": False,
    "cacheClusterSize": "",
    "variables": {},
    "canarySettings": {
        "percentTraffic": "",
        "stageVariableOverrides": "",
        "useStageCache": ""
    },
    "tracingEnabled": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/deployments"

payload <- "{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/deployments")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/restapis/:restapi_id/deployments') do |req|
  req.body = "{\n  \"stageName\": \"\",\n  \"stageDescription\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "stageName": "",
        "stageDescription": "",
        "description": "",
        "cacheClusterEnabled": false,
        "cacheClusterSize": "",
        "variables": json!({}),
        "canarySettings": json!({
            "percentTraffic": "",
            "stageVariableOverrides": "",
            "useStageCache": ""
        }),
        "tracingEnabled": false
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/restapis/:restapi_id/deployments \
  --header 'content-type: application/json' \
  --data '{
  "stageName": "",
  "stageDescription": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "canarySettings": {
    "percentTraffic": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false
}'

echo '{
  "stageName": "",
  "stageDescription": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "canarySettings": {
    "percentTraffic": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false
}' |  \
  http POST {{baseUrl}}/restapis/:restapi_id/deployments \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "stageName": "",\n  "stageDescription": "",\n  "description": "",\n  "cacheClusterEnabled": false,\n  "cacheClusterSize": "",\n  "variables": {},\n  "canarySettings": {\n    "percentTraffic": "",\n    "stageVariableOverrides": "",\n    "useStageCache": ""\n  },\n  "tracingEnabled": false\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/deployments

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "stageName": "",
  "stageDescription": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": [],
  "canarySettings": [
    "percentTraffic": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  ],
  "tracingEnabled": false
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateDocumentationPart

{{baseUrl}}/restapis/:restapi_id/documentation/parts

QUERY PARAMS

restapi_id

BODY json

{
  "location": {
    "type": "",
    "path": "",
    "method": "",
    "statusCode": "",
    "name": ""
  },
  "properties": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/documentation/parts");

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  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/restapis/:restapi_id/documentation/parts" {:content-type :json
                                                                                     :form-params {:location {:type ""
                                                                                                              :path ""
                                                                                                              :method ""
                                                                                                              :statusCode ""
                                                                                                              :name ""}
                                                                                                   :properties ""}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/documentation/parts"),
    Content = new StringContent("{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\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}}/restapis/:restapi_id/documentation/parts");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/documentation/parts"

	payload := strings.NewReader("{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/restapis/:restapi_id/documentation/parts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "location": {
    "type": "",
    "path": "",
    "method": "",
    "statusCode": "",
    "name": ""
  },
  "properties": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis/:restapi_id/documentation/parts")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/restapis/:restapi_id/documentation/parts")
  .header("content-type", "application/json")
  .body("{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  location: {
    type: '',
    path: '',
    method: '',
    statusCode: '',
    name: ''
  },
  properties: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/restapis/:restapi_id/documentation/parts');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts',
  headers: {'content-type': 'application/json'},
  data: {
    location: {type: '', path: '', method: '', statusCode: '', name: ''},
    properties: ''
  }
};

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

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"location":{"type":"","path":"","method":"","statusCode":"","name":""},"properties":""}'
};

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}}/restapis/:restapi_id/documentation/parts',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "location": {\n    "type": "",\n    "path": "",\n    "method": "",\n    "statusCode": "",\n    "name": ""\n  },\n  "properties": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/parts")
  .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/restapis/:restapi_id/documentation/parts',
  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({
  location: {type: '', path: '', method: '', statusCode: '', name: ''},
  properties: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts',
  headers: {'content-type': 'application/json'},
  body: {
    location: {type: '', path: '', method: '', statusCode: '', name: ''},
    properties: ''
  },
  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}}/restapis/:restapi_id/documentation/parts');

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

req.type('json');
req.send({
  location: {
    type: '',
    path: '',
    method: '',
    statusCode: '',
    name: ''
  },
  properties: ''
});

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}}/restapis/:restapi_id/documentation/parts',
  headers: {'content-type': 'application/json'},
  data: {
    location: {type: '', path: '', method: '', statusCode: '', name: ''},
    properties: ''
  }
};

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

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

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"location":{"type":"","path":"","method":"","statusCode":"","name":""},"properties":""}'
};

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 = @{ @"location": @{ @"type": @"", @"path": @"", @"method": @"", @"statusCode": @"", @"name": @"" },
                              @"properties": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/documentation/parts"]
                                                       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}}/restapis/:restapi_id/documentation/parts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}" in

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

 "{{baseUrl}}/restapis/:restapi_id/documentation/parts",
  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([
    'location' => [
        'type' => '',
        'path' => '',
        'method' => '',
        'statusCode' => '',
        'name' => ''
    ],
    'properties' => ''
  ]),
  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}}/restapis/:restapi_id/documentation/parts', [
  'body' => '{
  "location": {
    "type": "",
    "path": "",
    "method": "",
    "statusCode": "",
    "name": ""
  },
  "properties": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'location' => [
    'type' => '',
    'path' => '',
    'method' => '',
    'statusCode' => '',
    'name' => ''
  ],
  'properties' => ''
]));

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

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

append(json_encode([
  'location' => [
    'type' => '',
    'path' => '',
    'method' => '',
    'statusCode' => '',
    'name' => ''
  ],
  'properties' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts');
$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}}/restapis/:restapi_id/documentation/parts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "location": {
    "type": "",
    "path": "",
    "method": "",
    "statusCode": "",
    "name": ""
  },
  "properties": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/parts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "location": {
    "type": "",
    "path": "",
    "method": "",
    "statusCode": "",
    "name": ""
  },
  "properties": ""
}'

import http.client

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

payload = "{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}"

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

conn.request("POST", "/baseUrl/restapis/:restapi_id/documentation/parts", payload, headers)

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

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

import requests

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts"

payload = {
    "location": {
        "type": "",
        "path": "",
        "method": "",
        "statusCode": "",
        "name": ""
    },
    "properties": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/documentation/parts"

payload <- "{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/documentation/parts")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/restapis/:restapi_id/documentation/parts') do |req|
  req.body = "{\n  \"location\": {\n    \"type\": \"\",\n    \"path\": \"\",\n    \"method\": \"\",\n    \"statusCode\": \"\",\n    \"name\": \"\"\n  },\n  \"properties\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "location": json!({
            "type": "",
            "path": "",
            "method": "",
            "statusCode": "",
            "name": ""
        }),
        "properties": ""
    });

    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}}/restapis/:restapi_id/documentation/parts \
  --header 'content-type: application/json' \
  --data '{
  "location": {
    "type": "",
    "path": "",
    "method": "",
    "statusCode": "",
    "name": ""
  },
  "properties": ""
}'

echo '{
  "location": {
    "type": "",
    "path": "",
    "method": "",
    "statusCode": "",
    "name": ""
  },
  "properties": ""
}' |  \
  http POST {{baseUrl}}/restapis/:restapi_id/documentation/parts \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "location": {\n    "type": "",\n    "path": "",\n    "method": "",\n    "statusCode": "",\n    "name": ""\n  },\n  "properties": ""\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/documentation/parts

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "location": [
    "type": "",
    "path": "",
    "method": "",
    "statusCode": "",
    "name": ""
  ],
  "properties": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateDocumentationVersion

{{baseUrl}}/restapis/:restapi_id/documentation/versions

QUERY PARAMS

restapi_id

BODY json

{
  "documentationVersion": "",
  "stageName": "",
  "description": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/documentation/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, "{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/restapis/:restapi_id/documentation/versions" {:content-type :json
                                                                                        :form-params {:documentationVersion ""
                                                                                                      :stageName ""
                                                                                                      :description ""}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/documentation/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/documentation/versions"),
    Content = new StringContent("{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\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}}/restapis/:restapi_id/documentation/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/documentation/versions"

	payload := strings.NewReader("{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/restapis/:restapi_id/documentation/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 72

{
  "documentationVersion": "",
  "stageName": "",
  "description": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis/:restapi_id/documentation/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/restapis/:restapi_id/documentation/versions")
  .header("content-type", "application/json")
  .body("{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  documentationVersion: '',
  stageName: '',
  description: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/restapis/:restapi_id/documentation/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/versions',
  headers: {'content-type': 'application/json'},
  data: {documentationVersion: '', stageName: '', description: ''}
};

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

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"documentationVersion":"","stageName":"","description":""}'
};

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}}/restapis/:restapi_id/documentation/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "documentationVersion": "",\n  "stageName": "",\n  "description": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/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/restapis/:restapi_id/documentation/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({documentationVersion: '', stageName: '', description: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/versions',
  headers: {'content-type': 'application/json'},
  body: {documentationVersion: '', stageName: '', description: ''},
  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}}/restapis/:restapi_id/documentation/versions');

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

req.type('json');
req.send({
  documentationVersion: '',
  stageName: '',
  description: ''
});

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}}/restapis/:restapi_id/documentation/versions',
  headers: {'content-type': 'application/json'},
  data: {documentationVersion: '', stageName: '', description: ''}
};

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

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

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"documentationVersion":"","stageName":"","description":""}'
};

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 = @{ @"documentationVersion": @"",
                              @"stageName": @"",
                              @"description": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}" in

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

 "{{baseUrl}}/restapis/:restapi_id/documentation/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([
    'documentationVersion' => '',
    'stageName' => '',
    'description' => ''
  ]),
  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}}/restapis/:restapi_id/documentation/versions', [
  'body' => '{
  "documentationVersion": "",
  "stageName": "",
  "description": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/documentation/versions');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'documentationVersion' => '',
  'stageName' => '',
  'description' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "documentationVersion": "",
  "stageName": "",
  "description": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "documentationVersion": "",
  "stageName": "",
  "description": ""
}'

import http.client

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

payload = "{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}"

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

conn.request("POST", "/baseUrl/restapis/:restapi_id/documentation/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/restapis/:restapi_id/documentation/versions"

payload = {
    "documentationVersion": "",
    "stageName": "",
    "description": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/documentation/versions"

payload <- "{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/documentation/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 = "{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/restapis/:restapi_id/documentation/versions') do |req|
  req.body = "{\n  \"documentationVersion\": \"\",\n  \"stageName\": \"\",\n  \"description\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "documentationVersion": "",
        "stageName": "",
        "description": ""
    });

    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}}/restapis/:restapi_id/documentation/versions \
  --header 'content-type: application/json' \
  --data '{
  "documentationVersion": "",
  "stageName": "",
  "description": ""
}'

echo '{
  "documentationVersion": "",
  "stageName": "",
  "description": ""
}' |  \
  http POST {{baseUrl}}/restapis/:restapi_id/documentation/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "documentationVersion": "",\n  "stageName": "",\n  "description": ""\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/documentation/versions

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/documentation/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()

POST CreateDomainName

{{baseUrl}}/domainnames

BODY json

{
  "domainName": "",
  "certificateName": "",
  "certificateBody": "",
  "certificatePrivateKey": "",
  "certificateChain": "",
  "certificateArn": "",
  "regionalCertificateName": "",
  "regionalCertificateArn": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "tags": {},
  "securityPolicy": "",
  "mutualTlsAuthentication": {
    "truststoreUri": "",
    "truststoreVersion": ""
  },
  "ownershipVerificationCertificateArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domainnames" {:content-type :json
                                                        :form-params {:domainName ""
                                                                      :certificateName ""
                                                                      :certificateBody ""
                                                                      :certificatePrivateKey ""
                                                                      :certificateChain ""
                                                                      :certificateArn ""
                                                                      :regionalCertificateName ""
                                                                      :regionalCertificateArn ""
                                                                      :endpointConfiguration {:types ""
                                                                                              :vpcEndpointIds ""}
                                                                      :tags {}
                                                                      :securityPolicy ""
                                                                      :mutualTlsAuthentication {:truststoreUri ""
                                                                                                :truststoreVersion ""}
                                                                      :ownershipVerificationCertificateArn ""}})

require "http/client"

url = "{{baseUrl}}/domainnames"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/domainnames"),
    Content = new StringContent("{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\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}}/domainnames");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/domainnames HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 466

{
  "domainName": "",
  "certificateName": "",
  "certificateBody": "",
  "certificatePrivateKey": "",
  "certificateChain": "",
  "certificateArn": "",
  "regionalCertificateName": "",
  "regionalCertificateArn": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "tags": {},
  "securityPolicy": "",
  "mutualTlsAuthentication": {
    "truststoreUri": "",
    "truststoreVersion": ""
  },
  "ownershipVerificationCertificateArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domainnames")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domainnames"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domainnames")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domainnames")
  .header("content-type", "application/json")
  .body("{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domainName: '',
  certificateName: '',
  certificateBody: '',
  certificatePrivateKey: '',
  certificateChain: '',
  certificateArn: '',
  regionalCertificateName: '',
  regionalCertificateArn: '',
  endpointConfiguration: {
    types: '',
    vpcEndpointIds: ''
  },
  tags: {},
  securityPolicy: '',
  mutualTlsAuthentication: {
    truststoreUri: '',
    truststoreVersion: ''
  },
  ownershipVerificationCertificateArn: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domainnames',
  headers: {'content-type': 'application/json'},
  data: {
    domainName: '',
    certificateName: '',
    certificateBody: '',
    certificatePrivateKey: '',
    certificateChain: '',
    certificateArn: '',
    regionalCertificateName: '',
    regionalCertificateArn: '',
    endpointConfiguration: {types: '', vpcEndpointIds: ''},
    tags: {},
    securityPolicy: '',
    mutualTlsAuthentication: {truststoreUri: '', truststoreVersion: ''},
    ownershipVerificationCertificateArn: ''
  }
};

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

const url = '{{baseUrl}}/domainnames';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"domainName":"","certificateName":"","certificateBody":"","certificatePrivateKey":"","certificateChain":"","certificateArn":"","regionalCertificateName":"","regionalCertificateArn":"","endpointConfiguration":{"types":"","vpcEndpointIds":""},"tags":{},"securityPolicy":"","mutualTlsAuthentication":{"truststoreUri":"","truststoreVersion":""},"ownershipVerificationCertificateArn":""}'
};

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}}/domainnames',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domainName": "",\n  "certificateName": "",\n  "certificateBody": "",\n  "certificatePrivateKey": "",\n  "certificateChain": "",\n  "certificateArn": "",\n  "regionalCertificateName": "",\n  "regionalCertificateArn": "",\n  "endpointConfiguration": {\n    "types": "",\n    "vpcEndpointIds": ""\n  },\n  "tags": {},\n  "securityPolicy": "",\n  "mutualTlsAuthentication": {\n    "truststoreUri": "",\n    "truststoreVersion": ""\n  },\n  "ownershipVerificationCertificateArn": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domainnames")
  .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/domainnames',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  domainName: '',
  certificateName: '',
  certificateBody: '',
  certificatePrivateKey: '',
  certificateChain: '',
  certificateArn: '',
  regionalCertificateName: '',
  regionalCertificateArn: '',
  endpointConfiguration: {types: '', vpcEndpointIds: ''},
  tags: {},
  securityPolicy: '',
  mutualTlsAuthentication: {truststoreUri: '', truststoreVersion: ''},
  ownershipVerificationCertificateArn: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domainnames',
  headers: {'content-type': 'application/json'},
  body: {
    domainName: '',
    certificateName: '',
    certificateBody: '',
    certificatePrivateKey: '',
    certificateChain: '',
    certificateArn: '',
    regionalCertificateName: '',
    regionalCertificateArn: '',
    endpointConfiguration: {types: '', vpcEndpointIds: ''},
    tags: {},
    securityPolicy: '',
    mutualTlsAuthentication: {truststoreUri: '', truststoreVersion: ''},
    ownershipVerificationCertificateArn: ''
  },
  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}}/domainnames');

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

req.type('json');
req.send({
  domainName: '',
  certificateName: '',
  certificateBody: '',
  certificatePrivateKey: '',
  certificateChain: '',
  certificateArn: '',
  regionalCertificateName: '',
  regionalCertificateArn: '',
  endpointConfiguration: {
    types: '',
    vpcEndpointIds: ''
  },
  tags: {},
  securityPolicy: '',
  mutualTlsAuthentication: {
    truststoreUri: '',
    truststoreVersion: ''
  },
  ownershipVerificationCertificateArn: ''
});

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}}/domainnames',
  headers: {'content-type': 'application/json'},
  data: {
    domainName: '',
    certificateName: '',
    certificateBody: '',
    certificatePrivateKey: '',
    certificateChain: '',
    certificateArn: '',
    regionalCertificateName: '',
    regionalCertificateArn: '',
    endpointConfiguration: {types: '', vpcEndpointIds: ''},
    tags: {},
    securityPolicy: '',
    mutualTlsAuthentication: {truststoreUri: '', truststoreVersion: ''},
    ownershipVerificationCertificateArn: ''
  }
};

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

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

const url = '{{baseUrl}}/domainnames';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"domainName":"","certificateName":"","certificateBody":"","certificatePrivateKey":"","certificateChain":"","certificateArn":"","regionalCertificateName":"","regionalCertificateArn":"","endpointConfiguration":{"types":"","vpcEndpointIds":""},"tags":{},"securityPolicy":"","mutualTlsAuthentication":{"truststoreUri":"","truststoreVersion":""},"ownershipVerificationCertificateArn":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domainName": @"",
                              @"certificateName": @"",
                              @"certificateBody": @"",
                              @"certificatePrivateKey": @"",
                              @"certificateChain": @"",
                              @"certificateArn": @"",
                              @"regionalCertificateName": @"",
                              @"regionalCertificateArn": @"",
                              @"endpointConfiguration": @{ @"types": @"", @"vpcEndpointIds": @"" },
                              @"tags": @{  },
                              @"securityPolicy": @"",
                              @"mutualTlsAuthentication": @{ @"truststoreUri": @"", @"truststoreVersion": @"" },
                              @"ownershipVerificationCertificateArn": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domainnames"]
                                                       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}}/domainnames" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}" in

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

 "{{baseUrl}}/domainnames",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domainName' => '',
    'certificateName' => '',
    'certificateBody' => '',
    'certificatePrivateKey' => '',
    'certificateChain' => '',
    'certificateArn' => '',
    'regionalCertificateName' => '',
    'regionalCertificateArn' => '',
    'endpointConfiguration' => [
        'types' => '',
        'vpcEndpointIds' => ''
    ],
    'tags' => [
        
    ],
    'securityPolicy' => '',
    'mutualTlsAuthentication' => [
        'truststoreUri' => '',
        'truststoreVersion' => ''
    ],
    'ownershipVerificationCertificateArn' => ''
  ]),
  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}}/domainnames', [
  'body' => '{
  "domainName": "",
  "certificateName": "",
  "certificateBody": "",
  "certificatePrivateKey": "",
  "certificateChain": "",
  "certificateArn": "",
  "regionalCertificateName": "",
  "regionalCertificateArn": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "tags": {},
  "securityPolicy": "",
  "mutualTlsAuthentication": {
    "truststoreUri": "",
    "truststoreVersion": ""
  },
  "ownershipVerificationCertificateArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domainName' => '',
  'certificateName' => '',
  'certificateBody' => '',
  'certificatePrivateKey' => '',
  'certificateChain' => '',
  'certificateArn' => '',
  'regionalCertificateName' => '',
  'regionalCertificateArn' => '',
  'endpointConfiguration' => [
    'types' => '',
    'vpcEndpointIds' => ''
  ],
  'tags' => [
    
  ],
  'securityPolicy' => '',
  'mutualTlsAuthentication' => [
    'truststoreUri' => '',
    'truststoreVersion' => ''
  ],
  'ownershipVerificationCertificateArn' => ''
]));

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

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

append(json_encode([
  'domainName' => '',
  'certificateName' => '',
  'certificateBody' => '',
  'certificatePrivateKey' => '',
  'certificateChain' => '',
  'certificateArn' => '',
  'regionalCertificateName' => '',
  'regionalCertificateArn' => '',
  'endpointConfiguration' => [
    'types' => '',
    'vpcEndpointIds' => ''
  ],
  'tags' => [
    
  ],
  'securityPolicy' => '',
  'mutualTlsAuthentication' => [
    'truststoreUri' => '',
    'truststoreVersion' => ''
  ],
  'ownershipVerificationCertificateArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/domainnames');
$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}}/domainnames' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domainName": "",
  "certificateName": "",
  "certificateBody": "",
  "certificatePrivateKey": "",
  "certificateChain": "",
  "certificateArn": "",
  "regionalCertificateName": "",
  "regionalCertificateArn": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "tags": {},
  "securityPolicy": "",
  "mutualTlsAuthentication": {
    "truststoreUri": "",
    "truststoreVersion": ""
  },
  "ownershipVerificationCertificateArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainnames' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domainName": "",
  "certificateName": "",
  "certificateBody": "",
  "certificatePrivateKey": "",
  "certificateChain": "",
  "certificateArn": "",
  "regionalCertificateName": "",
  "regionalCertificateArn": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "tags": {},
  "securityPolicy": "",
  "mutualTlsAuthentication": {
    "truststoreUri": "",
    "truststoreVersion": ""
  },
  "ownershipVerificationCertificateArn": ""
}'

import http.client

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

payload = "{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/domainnames"

payload = {
    "domainName": "",
    "certificateName": "",
    "certificateBody": "",
    "certificatePrivateKey": "",
    "certificateChain": "",
    "certificateArn": "",
    "regionalCertificateName": "",
    "regionalCertificateArn": "",
    "endpointConfiguration": {
        "types": "",
        "vpcEndpointIds": ""
    },
    "tags": {},
    "securityPolicy": "",
    "mutualTlsAuthentication": {
        "truststoreUri": "",
        "truststoreVersion": ""
    },
    "ownershipVerificationCertificateArn": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/domainnames') do |req|
  req.body = "{\n  \"domainName\": \"\",\n  \"certificateName\": \"\",\n  \"certificateBody\": \"\",\n  \"certificatePrivateKey\": \"\",\n  \"certificateChain\": \"\",\n  \"certificateArn\": \"\",\n  \"regionalCertificateName\": \"\",\n  \"regionalCertificateArn\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"tags\": {},\n  \"securityPolicy\": \"\",\n  \"mutualTlsAuthentication\": {\n    \"truststoreUri\": \"\",\n    \"truststoreVersion\": \"\"\n  },\n  \"ownershipVerificationCertificateArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domainName": "",
        "certificateName": "",
        "certificateBody": "",
        "certificatePrivateKey": "",
        "certificateChain": "",
        "certificateArn": "",
        "regionalCertificateName": "",
        "regionalCertificateArn": "",
        "endpointConfiguration": json!({
            "types": "",
            "vpcEndpointIds": ""
        }),
        "tags": json!({}),
        "securityPolicy": "",
        "mutualTlsAuthentication": json!({
            "truststoreUri": "",
            "truststoreVersion": ""
        }),
        "ownershipVerificationCertificateArn": ""
    });

    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}}/domainnames \
  --header 'content-type: application/json' \
  --data '{
  "domainName": "",
  "certificateName": "",
  "certificateBody": "",
  "certificatePrivateKey": "",
  "certificateChain": "",
  "certificateArn": "",
  "regionalCertificateName": "",
  "regionalCertificateArn": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "tags": {},
  "securityPolicy": "",
  "mutualTlsAuthentication": {
    "truststoreUri": "",
    "truststoreVersion": ""
  },
  "ownershipVerificationCertificateArn": ""
}'

echo '{
  "domainName": "",
  "certificateName": "",
  "certificateBody": "",
  "certificatePrivateKey": "",
  "certificateChain": "",
  "certificateArn": "",
  "regionalCertificateName": "",
  "regionalCertificateArn": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "tags": {},
  "securityPolicy": "",
  "mutualTlsAuthentication": {
    "truststoreUri": "",
    "truststoreVersion": ""
  },
  "ownershipVerificationCertificateArn": ""
}' |  \
  http POST {{baseUrl}}/domainnames \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "domainName": "",\n  "certificateName": "",\n  "certificateBody": "",\n  "certificatePrivateKey": "",\n  "certificateChain": "",\n  "certificateArn": "",\n  "regionalCertificateName": "",\n  "regionalCertificateArn": "",\n  "endpointConfiguration": {\n    "types": "",\n    "vpcEndpointIds": ""\n  },\n  "tags": {},\n  "securityPolicy": "",\n  "mutualTlsAuthentication": {\n    "truststoreUri": "",\n    "truststoreVersion": ""\n  },\n  "ownershipVerificationCertificateArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/domainnames

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "domainName": "",
  "certificateName": "",
  "certificateBody": "",
  "certificatePrivateKey": "",
  "certificateChain": "",
  "certificateArn": "",
  "regionalCertificateName": "",
  "regionalCertificateArn": "",
  "endpointConfiguration": [
    "types": "",
    "vpcEndpointIds": ""
  ],
  "tags": [],
  "securityPolicy": "",
  "mutualTlsAuthentication": [
    "truststoreUri": "",
    "truststoreVersion": ""
  ],
  "ownershipVerificationCertificateArn": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateModel

{{baseUrl}}/restapis/:restapi_id/models

QUERY PARAMS

restapi_id

BODY json

{
  "name": "",
  "description": "",
  "schema": "",
  "contentType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/models");

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  \"name\": \"\",\n  \"description\": \"\",\n  \"schema\": \"\",\n  \"contentType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/restapis/:restapi_id/models" {:content-type :json
                                                                        :form-params {:name ""
                                                                                      :description ""
                                                                                      :schema ""
                                                                                      :contentType ""}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/models"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"schema\": \"\",\n  \"contentType\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/models"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"schema\": \"\",\n  \"contentType\": \"\"\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}}/restapis/:restapi_id/models");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"schema\": \"\",\n  \"contentType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/models"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"schema\": \"\",\n  \"contentType\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/restapis/:restapi_id/models HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 74

{
  "name": "",
  "description": "",
  "schema": "",
  "contentType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis/:restapi_id/models")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"schema\": \"\",\n  \"contentType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/restapis/:restapi_id/models")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"schema\": \"\",\n  \"contentType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  description: '',
  schema: '',
  contentType: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/restapis/:restapi_id/models');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/models',
  headers: {'content-type': 'application/json'},
  data: {name: '', description: '', schema: '', contentType: ''}
};

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

const url = '{{baseUrl}}/restapis/:restapi_id/models';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","description":"","schema":"","contentType":""}'
};

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}}/restapis/:restapi_id/models',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "description": "",\n  "schema": "",\n  "contentType": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/models',
  headers: {'content-type': 'application/json'},
  body: {name: '', description: '', schema: '', contentType: ''},
  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}}/restapis/:restapi_id/models');

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

req.type('json');
req.send({
  name: '',
  description: '',
  schema: '',
  contentType: ''
});

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}}/restapis/:restapi_id/models',
  headers: {'content-type': 'application/json'},
  data: {name: '', description: '', schema: '', contentType: ''}
};

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

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

const url = '{{baseUrl}}/restapis/:restapi_id/models';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","description":"","schema":"","contentType":""}'
};

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 = @{ @"name": @"",
                              @"description": @"",
                              @"schema": @"",
                              @"contentType": @"" };

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

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

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

 "{{baseUrl}}/restapis/:restapi_id/models",
  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([
    'name' => '',
    'description' => '',
    'schema' => '',
    'contentType' => ''
  ]),
  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}}/restapis/:restapi_id/models', [
  'body' => '{
  "name": "",
  "description": "",
  "schema": "",
  "contentType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/models');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'description' => '',
  'schema' => '',
  'contentType' => ''
]));

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

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

append(json_encode([
  'name' => '',
  'description' => '',
  'schema' => '',
  'contentType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/models');
$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}}/restapis/:restapi_id/models' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "description": "",
  "schema": "",
  "contentType": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/models' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "description": "",
  "schema": "",
  "contentType": ""
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"schema\": \"\",\n  \"contentType\": \"\"\n}"

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

conn.request("POST", "/baseUrl/restapis/:restapi_id/models", payload, headers)

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

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

import requests

url = "{{baseUrl}}/restapis/:restapi_id/models"

payload = {
    "name": "",
    "description": "",
    "schema": "",
    "contentType": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/models"

payload <- "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"schema\": \"\",\n  \"contentType\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/models")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"schema\": \"\",\n  \"contentType\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/restapis/:restapi_id/models') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"schema\": \"\",\n  \"contentType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "name": "",
        "description": "",
        "schema": "",
        "contentType": ""
    });

    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}}/restapis/:restapi_id/models \
  --header 'content-type: application/json' \
  --data '{
  "name": "",
  "description": "",
  "schema": "",
  "contentType": ""
}'

echo '{
  "name": "",
  "description": "",
  "schema": "",
  "contentType": ""
}' |  \
  http POST {{baseUrl}}/restapis/:restapi_id/models \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "description": "",\n  "schema": "",\n  "contentType": ""\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/models

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "description": "",
  "schema": "",
  "contentType": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateRequestValidator

{{baseUrl}}/restapis/:restapi_id/requestvalidators

QUERY PARAMS

restapi_id

BODY json

{
  "name": "",
  "validateRequestBody": false,
  "validateRequestParameters": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/requestvalidators");

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  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/restapis/:restapi_id/requestvalidators" {:content-type :json
                                                                                   :form-params {:name ""
                                                                                                 :validateRequestBody false
                                                                                                 :validateRequestParameters false}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": false\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/requestvalidators"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": 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}}/restapis/:restapi_id/requestvalidators");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/requestvalidators"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": false\n}")

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

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

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

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

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

}

POST /baseUrl/restapis/:restapi_id/requestvalidators HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 86

{
  "name": "",
  "validateRequestBody": false,
  "validateRequestParameters": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis/:restapi_id/requestvalidators")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/restapis/:restapi_id/requestvalidators")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": false\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  validateRequestBody: false,
  validateRequestParameters: false
});

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

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

xhr.open('POST', '{{baseUrl}}/restapis/:restapi_id/requestvalidators');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators',
  headers: {'content-type': 'application/json'},
  data: {name: '', validateRequestBody: false, validateRequestParameters: false}
};

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

const url = '{{baseUrl}}/restapis/:restapi_id/requestvalidators';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","validateRequestBody":false,"validateRequestParameters":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}}/restapis/:restapi_id/requestvalidators',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "validateRequestBody": false,\n  "validateRequestParameters": 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  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/requestvalidators")
  .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/restapis/:restapi_id/requestvalidators',
  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({name: '', validateRequestBody: false, validateRequestParameters: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators',
  headers: {'content-type': 'application/json'},
  body: {name: '', validateRequestBody: false, validateRequestParameters: false},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restapis/:restapi_id/requestvalidators');

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

req.type('json');
req.send({
  name: '',
  validateRequestBody: false,
  validateRequestParameters: false
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators',
  headers: {'content-type': 'application/json'},
  data: {name: '', validateRequestBody: false, validateRequestParameters: false}
};

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

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

const url = '{{baseUrl}}/restapis/:restapi_id/requestvalidators';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","validateRequestBody":false,"validateRequestParameters":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 = @{ @"name": @"",
                              @"validateRequestBody": @NO,
                              @"validateRequestParameters": @NO };

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

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

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

 "{{baseUrl}}/restapis/:restapi_id/requestvalidators",
  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([
    'name' => '',
    'validateRequestBody' => null,
    'validateRequestParameters' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/restapis/:restapi_id/requestvalidators', [
  'body' => '{
  "name": "",
  "validateRequestBody": false,
  "validateRequestParameters": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/requestvalidators');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'validateRequestBody' => null,
  'validateRequestParameters' => null
]));

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

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

append(json_encode([
  'name' => '',
  'validateRequestBody' => null,
  'validateRequestParameters' => null
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/requestvalidators');
$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}}/restapis/:restapi_id/requestvalidators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "validateRequestBody": false,
  "validateRequestParameters": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/requestvalidators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "validateRequestBody": false,
  "validateRequestParameters": false
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": false\n}"

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

conn.request("POST", "/baseUrl/restapis/:restapi_id/requestvalidators", payload, headers)

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

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

import requests

url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators"

payload = {
    "name": "",
    "validateRequestBody": False,
    "validateRequestParameters": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/requestvalidators"

payload <- "{\n  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": false\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/requestvalidators")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": false\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/restapis/:restapi_id/requestvalidators') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"validateRequestBody\": false,\n  \"validateRequestParameters\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "name": "",
        "validateRequestBody": false,
        "validateRequestParameters": false
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/restapis/:restapi_id/requestvalidators \
  --header 'content-type: application/json' \
  --data '{
  "name": "",
  "validateRequestBody": false,
  "validateRequestParameters": false
}'

echo '{
  "name": "",
  "validateRequestBody": false,
  "validateRequestParameters": false
}' |  \
  http POST {{baseUrl}}/restapis/:restapi_id/requestvalidators \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "validateRequestBody": false,\n  "validateRequestParameters": false\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/requestvalidators

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "validateRequestBody": false,
  "validateRequestParameters": false
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateResource

{{baseUrl}}/restapis/:restapi_id/resources/:parent_id

QUERY PARAMS

restapi_id

parent_id

BODY json

{
  "pathPart": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:parent_id");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"pathPart\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/restapis/:restapi_id/resources/:parent_id" {:content-type :json
                                                                                      :form-params {:pathPart ""}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:parent_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pathPart\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/resources/:parent_id"),
    Content = new StringContent("{\n  \"pathPart\": \"\"\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}}/restapis/:restapi_id/resources/:parent_id");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pathPart\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:parent_id"

	payload := strings.NewReader("{\n  \"pathPart\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/restapis/:restapi_id/resources/:parent_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "pathPart": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis/:restapi_id/resources/:parent_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pathPart\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/restapis/:restapi_id/resources/:parent_id")
  .header("content-type", "application/json")
  .body("{\n  \"pathPart\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/restapis/:restapi_id/resources/:parent_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:parent_id',
  headers: {'content-type': 'application/json'},
  data: {pathPart: ''}
};

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

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:parent_id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pathPart":""}'
};

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}}/restapis/:restapi_id/resources/:parent_id',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pathPart": ""\n}'
};

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

val client = OkHttpClient()

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

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

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

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

req.write(JSON.stringify({pathPart: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:parent_id',
  headers: {'content-type': 'application/json'},
  body: {pathPart: ''},
  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}}/restapis/:restapi_id/resources/:parent_id');

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

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

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}}/restapis/:restapi_id/resources/:parent_id',
  headers: {'content-type': 'application/json'},
  data: {pathPart: ''}
};

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

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

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:parent_id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pathPart":""}'
};

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

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

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

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

 "{{baseUrl}}/restapis/:restapi_id/resources/:parent_id",
  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([
    'pathPart' => ''
  ]),
  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}}/restapis/:restapi_id/resources/:parent_id', [
  'body' => '{
  "pathPart": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:parent_id');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'pathPart' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:parent_id');
$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}}/restapis/:restapi_id/resources/:parent_id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pathPart": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:parent_id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pathPart": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/restapis/:restapi_id/resources/:parent_id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:parent_id"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:parent_id"

payload <- "{\n  \"pathPart\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:parent_id")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"pathPart\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/restapis/:restapi_id/resources/:parent_id') do |req|
  req.body = "{\n  \"pathPart\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

    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}}/restapis/:restapi_id/resources/:parent_id \
  --header 'content-type: application/json' \
  --data '{
  "pathPart": ""
}'

echo '{
  "pathPart": ""
}' |  \
  http POST {{baseUrl}}/restapis/:restapi_id/resources/:parent_id \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "pathPart": ""\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:parent_id

import Foundation

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

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

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

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

dataTask.resume()

POST CreateRestApi

{{baseUrl}}/restapis

BODY json

{
  "name": "",
  "description": "",
  "version": "",
  "cloneFrom": "",
  "binaryMediaTypes": [],
  "minimumCompressionSize": 0,
  "apiKeySource": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "policy": "",
  "tags": {},
  "disableExecuteApiEndpoint": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/restapis" {:content-type :json
                                                     :form-params {:name ""
                                                                   :description ""
                                                                   :version ""
                                                                   :cloneFrom ""
                                                                   :binaryMediaTypes []
                                                                   :minimumCompressionSize 0
                                                                   :apiKeySource ""
                                                                   :endpointConfiguration {:types ""
                                                                                           :vpcEndpointIds ""}
                                                                   :policy ""
                                                                   :tags {}
                                                                   :disableExecuteApiEndpoint false}})

require "http/client"

url = "{{baseUrl}}/restapis"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": 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}}/restapis");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}")

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

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

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

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

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

}

POST /baseUrl/restapis HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 296

{
  "name": "",
  "description": "",
  "version": "",
  "cloneFrom": "",
  "binaryMediaTypes": [],
  "minimumCompressionSize": 0,
  "apiKeySource": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "policy": "",
  "tags": {},
  "disableExecuteApiEndpoint": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": 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  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/restapis")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  description: '',
  version: '',
  cloneFrom: '',
  binaryMediaTypes: [],
  minimumCompressionSize: 0,
  apiKeySource: '',
  endpointConfiguration: {
    types: '',
    vpcEndpointIds: ''
  },
  policy: '',
  tags: {},
  disableExecuteApiEndpoint: false
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    description: '',
    version: '',
    cloneFrom: '',
    binaryMediaTypes: [],
    minimumCompressionSize: 0,
    apiKeySource: '',
    endpointConfiguration: {types: '', vpcEndpointIds: ''},
    policy: '',
    tags: {},
    disableExecuteApiEndpoint: false
  }
};

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

const url = '{{baseUrl}}/restapis';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","description":"","version":"","cloneFrom":"","binaryMediaTypes":[],"minimumCompressionSize":0,"apiKeySource":"","endpointConfiguration":{"types":"","vpcEndpointIds":""},"policy":"","tags":{},"disableExecuteApiEndpoint":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}}/restapis',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "description": "",\n  "version": "",\n  "cloneFrom": "",\n  "binaryMediaTypes": [],\n  "minimumCompressionSize": 0,\n  "apiKeySource": "",\n  "endpointConfiguration": {\n    "types": "",\n    "vpcEndpointIds": ""\n  },\n  "policy": "",\n  "tags": {},\n  "disableExecuteApiEndpoint": 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  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis")
  .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/restapis',
  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({
  name: '',
  description: '',
  version: '',
  cloneFrom: '',
  binaryMediaTypes: [],
  minimumCompressionSize: 0,
  apiKeySource: '',
  endpointConfiguration: {types: '', vpcEndpointIds: ''},
  policy: '',
  tags: {},
  disableExecuteApiEndpoint: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    description: '',
    version: '',
    cloneFrom: '',
    binaryMediaTypes: [],
    minimumCompressionSize: 0,
    apiKeySource: '',
    endpointConfiguration: {types: '', vpcEndpointIds: ''},
    policy: '',
    tags: {},
    disableExecuteApiEndpoint: false
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/restapis');

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

req.type('json');
req.send({
  name: '',
  description: '',
  version: '',
  cloneFrom: '',
  binaryMediaTypes: [],
  minimumCompressionSize: 0,
  apiKeySource: '',
  endpointConfiguration: {
    types: '',
    vpcEndpointIds: ''
  },
  policy: '',
  tags: {},
  disableExecuteApiEndpoint: false
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    description: '',
    version: '',
    cloneFrom: '',
    binaryMediaTypes: [],
    minimumCompressionSize: 0,
    apiKeySource: '',
    endpointConfiguration: {types: '', vpcEndpointIds: ''},
    policy: '',
    tags: {},
    disableExecuteApiEndpoint: false
  }
};

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

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

const url = '{{baseUrl}}/restapis';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","description":"","version":"","cloneFrom":"","binaryMediaTypes":[],"minimumCompressionSize":0,"apiKeySource":"","endpointConfiguration":{"types":"","vpcEndpointIds":""},"policy":"","tags":{},"disableExecuteApiEndpoint":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 = @{ @"name": @"",
                              @"description": @"",
                              @"version": @"",
                              @"cloneFrom": @"",
                              @"binaryMediaTypes": @[  ],
                              @"minimumCompressionSize": @0,
                              @"apiKeySource": @"",
                              @"endpointConfiguration": @{ @"types": @"", @"vpcEndpointIds": @"" },
                              @"policy": @"",
                              @"tags": @{  },
                              @"disableExecuteApiEndpoint": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis"]
                                                       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}}/restapis" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}" in

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

 "{{baseUrl}}/restapis",
  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([
    'name' => '',
    'description' => '',
    'version' => '',
    'cloneFrom' => '',
    'binaryMediaTypes' => [
        
    ],
    'minimumCompressionSize' => 0,
    'apiKeySource' => '',
    'endpointConfiguration' => [
        'types' => '',
        'vpcEndpointIds' => ''
    ],
    'policy' => '',
    'tags' => [
        
    ],
    'disableExecuteApiEndpoint' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/restapis', [
  'body' => '{
  "name": "",
  "description": "",
  "version": "",
  "cloneFrom": "",
  "binaryMediaTypes": [],
  "minimumCompressionSize": 0,
  "apiKeySource": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "policy": "",
  "tags": {},
  "disableExecuteApiEndpoint": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'description' => '',
  'version' => '',
  'cloneFrom' => '',
  'binaryMediaTypes' => [
    
  ],
  'minimumCompressionSize' => 0,
  'apiKeySource' => '',
  'endpointConfiguration' => [
    'types' => '',
    'vpcEndpointIds' => ''
  ],
  'policy' => '',
  'tags' => [
    
  ],
  'disableExecuteApiEndpoint' => null
]));

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

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

append(json_encode([
  'name' => '',
  'description' => '',
  'version' => '',
  'cloneFrom' => '',
  'binaryMediaTypes' => [
    
  ],
  'minimumCompressionSize' => 0,
  'apiKeySource' => '',
  'endpointConfiguration' => [
    'types' => '',
    'vpcEndpointIds' => ''
  ],
  'policy' => '',
  'tags' => [
    
  ],
  'disableExecuteApiEndpoint' => null
]));
$request->setRequestUrl('{{baseUrl}}/restapis');
$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}}/restapis' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "description": "",
  "version": "",
  "cloneFrom": "",
  "binaryMediaTypes": [],
  "minimumCompressionSize": 0,
  "apiKeySource": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "policy": "",
  "tags": {},
  "disableExecuteApiEndpoint": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "description": "",
  "version": "",
  "cloneFrom": "",
  "binaryMediaTypes": [],
  "minimumCompressionSize": 0,
  "apiKeySource": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "policy": "",
  "tags": {},
  "disableExecuteApiEndpoint": false
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/restapis"

payload = {
    "name": "",
    "description": "",
    "version": "",
    "cloneFrom": "",
    "binaryMediaTypes": [],
    "minimumCompressionSize": 0,
    "apiKeySource": "",
    "endpointConfiguration": {
        "types": "",
        "vpcEndpointIds": ""
    },
    "policy": "",
    "tags": {},
    "disableExecuteApiEndpoint": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/restapis') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"version\": \"\",\n  \"cloneFrom\": \"\",\n  \"binaryMediaTypes\": [],\n  \"minimumCompressionSize\": 0,\n  \"apiKeySource\": \"\",\n  \"endpointConfiguration\": {\n    \"types\": \"\",\n    \"vpcEndpointIds\": \"\"\n  },\n  \"policy\": \"\",\n  \"tags\": {},\n  \"disableExecuteApiEndpoint\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "name": "",
        "description": "",
        "version": "",
        "cloneFrom": "",
        "binaryMediaTypes": (),
        "minimumCompressionSize": 0,
        "apiKeySource": "",
        "endpointConfiguration": json!({
            "types": "",
            "vpcEndpointIds": ""
        }),
        "policy": "",
        "tags": json!({}),
        "disableExecuteApiEndpoint": false
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/restapis \
  --header 'content-type: application/json' \
  --data '{
  "name": "",
  "description": "",
  "version": "",
  "cloneFrom": "",
  "binaryMediaTypes": [],
  "minimumCompressionSize": 0,
  "apiKeySource": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "policy": "",
  "tags": {},
  "disableExecuteApiEndpoint": false
}'

echo '{
  "name": "",
  "description": "",
  "version": "",
  "cloneFrom": "",
  "binaryMediaTypes": [],
  "minimumCompressionSize": 0,
  "apiKeySource": "",
  "endpointConfiguration": {
    "types": "",
    "vpcEndpointIds": ""
  },
  "policy": "",
  "tags": {},
  "disableExecuteApiEndpoint": false
}' |  \
  http POST {{baseUrl}}/restapis \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "description": "",\n  "version": "",\n  "cloneFrom": "",\n  "binaryMediaTypes": [],\n  "minimumCompressionSize": 0,\n  "apiKeySource": "",\n  "endpointConfiguration": {\n    "types": "",\n    "vpcEndpointIds": ""\n  },\n  "policy": "",\n  "tags": {},\n  "disableExecuteApiEndpoint": false\n}' \
  --output-document \
  - {{baseUrl}}/restapis

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "description": "",
  "version": "",
  "cloneFrom": "",
  "binaryMediaTypes": [],
  "minimumCompressionSize": 0,
  "apiKeySource": "",
  "endpointConfiguration": [
    "types": "",
    "vpcEndpointIds": ""
  ],
  "policy": "",
  "tags": [],
  "disableExecuteApiEndpoint": false
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateStage

{{baseUrl}}/restapis/:restapi_id/stages

QUERY PARAMS

restapi_id

BODY json

{
  "stageName": "",
  "deploymentId": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "documentationVersion": "",
  "canarySettings": {
    "percentTraffic": "",
    "deploymentId": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false,
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/stages");

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  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/restapis/:restapi_id/stages" {:content-type :json
                                                                        :form-params {:stageName ""
                                                                                      :deploymentId ""
                                                                                      :description ""
                                                                                      :cacheClusterEnabled false
                                                                                      :cacheClusterSize ""
                                                                                      :variables {}
                                                                                      :documentationVersion ""
                                                                                      :canarySettings {:percentTraffic ""
                                                                                                       :deploymentId ""
                                                                                                       :stageVariableOverrides ""
                                                                                                       :useStageCache ""}
                                                                                      :tracingEnabled false
                                                                                      :tags {}}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/stages"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/stages"),
    Content = new StringContent("{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\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}}/restapis/:restapi_id/stages");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/stages"

	payload := strings.NewReader("{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}")

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

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

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

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

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

}

POST /baseUrl/restapis/:restapi_id/stages HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 347

{
  "stageName": "",
  "deploymentId": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "documentationVersion": "",
  "canarySettings": {
    "percentTraffic": "",
    "deploymentId": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false,
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis/:restapi_id/stages")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/stages"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\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  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/restapis/:restapi_id/stages")
  .header("content-type", "application/json")
  .body("{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  stageName: '',
  deploymentId: '',
  description: '',
  cacheClusterEnabled: false,
  cacheClusterSize: '',
  variables: {},
  documentationVersion: '',
  canarySettings: {
    percentTraffic: '',
    deploymentId: '',
    stageVariableOverrides: '',
    useStageCache: ''
  },
  tracingEnabled: false,
  tags: {}
});

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

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

xhr.open('POST', '{{baseUrl}}/restapis/:restapi_id/stages');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/stages',
  headers: {'content-type': 'application/json'},
  data: {
    stageName: '',
    deploymentId: '',
    description: '',
    cacheClusterEnabled: false,
    cacheClusterSize: '',
    variables: {},
    documentationVersion: '',
    canarySettings: {
      percentTraffic: '',
      deploymentId: '',
      stageVariableOverrides: '',
      useStageCache: ''
    },
    tracingEnabled: false,
    tags: {}
  }
};

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

const url = '{{baseUrl}}/restapis/:restapi_id/stages';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"stageName":"","deploymentId":"","description":"","cacheClusterEnabled":false,"cacheClusterSize":"","variables":{},"documentationVersion":"","canarySettings":{"percentTraffic":"","deploymentId":"","stageVariableOverrides":"","useStageCache":""},"tracingEnabled":false,"tags":{}}'
};

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}}/restapis/:restapi_id/stages',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "stageName": "",\n  "deploymentId": "",\n  "description": "",\n  "cacheClusterEnabled": false,\n  "cacheClusterSize": "",\n  "variables": {},\n  "documentationVersion": "",\n  "canarySettings": {\n    "percentTraffic": "",\n    "deploymentId": "",\n    "stageVariableOverrides": "",\n    "useStageCache": ""\n  },\n  "tracingEnabled": false,\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages")
  .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/restapis/:restapi_id/stages',
  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({
  stageName: '',
  deploymentId: '',
  description: '',
  cacheClusterEnabled: false,
  cacheClusterSize: '',
  variables: {},
  documentationVersion: '',
  canarySettings: {
    percentTraffic: '',
    deploymentId: '',
    stageVariableOverrides: '',
    useStageCache: ''
  },
  tracingEnabled: false,
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/stages',
  headers: {'content-type': 'application/json'},
  body: {
    stageName: '',
    deploymentId: '',
    description: '',
    cacheClusterEnabled: false,
    cacheClusterSize: '',
    variables: {},
    documentationVersion: '',
    canarySettings: {
      percentTraffic: '',
      deploymentId: '',
      stageVariableOverrides: '',
      useStageCache: ''
    },
    tracingEnabled: false,
    tags: {}
  },
  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}}/restapis/:restapi_id/stages');

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

req.type('json');
req.send({
  stageName: '',
  deploymentId: '',
  description: '',
  cacheClusterEnabled: false,
  cacheClusterSize: '',
  variables: {},
  documentationVersion: '',
  canarySettings: {
    percentTraffic: '',
    deploymentId: '',
    stageVariableOverrides: '',
    useStageCache: ''
  },
  tracingEnabled: false,
  tags: {}
});

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}}/restapis/:restapi_id/stages',
  headers: {'content-type': 'application/json'},
  data: {
    stageName: '',
    deploymentId: '',
    description: '',
    cacheClusterEnabled: false,
    cacheClusterSize: '',
    variables: {},
    documentationVersion: '',
    canarySettings: {
      percentTraffic: '',
      deploymentId: '',
      stageVariableOverrides: '',
      useStageCache: ''
    },
    tracingEnabled: false,
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/restapis/:restapi_id/stages';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"stageName":"","deploymentId":"","description":"","cacheClusterEnabled":false,"cacheClusterSize":"","variables":{},"documentationVersion":"","canarySettings":{"percentTraffic":"","deploymentId":"","stageVariableOverrides":"","useStageCache":""},"tracingEnabled":false,"tags":{}}'
};

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 = @{ @"stageName": @"",
                              @"deploymentId": @"",
                              @"description": @"",
                              @"cacheClusterEnabled": @NO,
                              @"cacheClusterSize": @"",
                              @"variables": @{  },
                              @"documentationVersion": @"",
                              @"canarySettings": @{ @"percentTraffic": @"", @"deploymentId": @"", @"stageVariableOverrides": @"", @"useStageCache": @"" },
                              @"tracingEnabled": @NO,
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/stages"]
                                                       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}}/restapis/:restapi_id/stages" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/restapis/:restapi_id/stages",
  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([
    'stageName' => '',
    'deploymentId' => '',
    'description' => '',
    'cacheClusterEnabled' => null,
    'cacheClusterSize' => '',
    'variables' => [
        
    ],
    'documentationVersion' => '',
    'canarySettings' => [
        'percentTraffic' => '',
        'deploymentId' => '',
        'stageVariableOverrides' => '',
        'useStageCache' => ''
    ],
    'tracingEnabled' => null,
    'tags' => [
        
    ]
  ]),
  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}}/restapis/:restapi_id/stages', [
  'body' => '{
  "stageName": "",
  "deploymentId": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "documentationVersion": "",
  "canarySettings": {
    "percentTraffic": "",
    "deploymentId": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false,
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/stages');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'stageName' => '',
  'deploymentId' => '',
  'description' => '',
  'cacheClusterEnabled' => null,
  'cacheClusterSize' => '',
  'variables' => [
    
  ],
  'documentationVersion' => '',
  'canarySettings' => [
    'percentTraffic' => '',
    'deploymentId' => '',
    'stageVariableOverrides' => '',
    'useStageCache' => ''
  ],
  'tracingEnabled' => null,
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'stageName' => '',
  'deploymentId' => '',
  'description' => '',
  'cacheClusterEnabled' => null,
  'cacheClusterSize' => '',
  'variables' => [
    
  ],
  'documentationVersion' => '',
  'canarySettings' => [
    'percentTraffic' => '',
    'deploymentId' => '',
    'stageVariableOverrides' => '',
    'useStageCache' => ''
  ],
  'tracingEnabled' => null,
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/stages');
$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}}/restapis/:restapi_id/stages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "stageName": "",
  "deploymentId": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "documentationVersion": "",
  "canarySettings": {
    "percentTraffic": "",
    "deploymentId": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false,
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/stages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "stageName": "",
  "deploymentId": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "documentationVersion": "",
  "canarySettings": {
    "percentTraffic": "",
    "deploymentId": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false,
  "tags": {}
}'

import http.client

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

payload = "{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/restapis/:restapi_id/stages", payload, headers)

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

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

import requests

url = "{{baseUrl}}/restapis/:restapi_id/stages"

payload = {
    "stageName": "",
    "deploymentId": "",
    "description": "",
    "cacheClusterEnabled": False,
    "cacheClusterSize": "",
    "variables": {},
    "documentationVersion": "",
    "canarySettings": {
        "percentTraffic": "",
        "deploymentId": "",
        "stageVariableOverrides": "",
        "useStageCache": ""
    },
    "tracingEnabled": False,
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/stages"

payload <- "{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/stages")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/restapis/:restapi_id/stages') do |req|
  req.body = "{\n  \"stageName\": \"\",\n  \"deploymentId\": \"\",\n  \"description\": \"\",\n  \"cacheClusterEnabled\": false,\n  \"cacheClusterSize\": \"\",\n  \"variables\": {},\n  \"documentationVersion\": \"\",\n  \"canarySettings\": {\n    \"percentTraffic\": \"\",\n    \"deploymentId\": \"\",\n    \"stageVariableOverrides\": \"\",\n    \"useStageCache\": \"\"\n  },\n  \"tracingEnabled\": false,\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "stageName": "",
        "deploymentId": "",
        "description": "",
        "cacheClusterEnabled": false,
        "cacheClusterSize": "",
        "variables": json!({}),
        "documentationVersion": "",
        "canarySettings": json!({
            "percentTraffic": "",
            "deploymentId": "",
            "stageVariableOverrides": "",
            "useStageCache": ""
        }),
        "tracingEnabled": false,
        "tags": 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}}/restapis/:restapi_id/stages \
  --header 'content-type: application/json' \
  --data '{
  "stageName": "",
  "deploymentId": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "documentationVersion": "",
  "canarySettings": {
    "percentTraffic": "",
    "deploymentId": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false,
  "tags": {}
}'

echo '{
  "stageName": "",
  "deploymentId": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": {},
  "documentationVersion": "",
  "canarySettings": {
    "percentTraffic": "",
    "deploymentId": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  },
  "tracingEnabled": false,
  "tags": {}
}' |  \
  http POST {{baseUrl}}/restapis/:restapi_id/stages \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "stageName": "",\n  "deploymentId": "",\n  "description": "",\n  "cacheClusterEnabled": false,\n  "cacheClusterSize": "",\n  "variables": {},\n  "documentationVersion": "",\n  "canarySettings": {\n    "percentTraffic": "",\n    "deploymentId": "",\n    "stageVariableOverrides": "",\n    "useStageCache": ""\n  },\n  "tracingEnabled": false,\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/stages

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "stageName": "",
  "deploymentId": "",
  "description": "",
  "cacheClusterEnabled": false,
  "cacheClusterSize": "",
  "variables": [],
  "documentationVersion": "",
  "canarySettings": [
    "percentTraffic": "",
    "deploymentId": "",
    "stageVariableOverrides": "",
    "useStageCache": ""
  ],
  "tracingEnabled": false,
  "tags": []
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateUsagePlan

{{baseUrl}}/usageplans

BODY json

{
  "name": "",
  "description": "",
  "apiStages": [
    {
      "apiId": "",
      "stage": "",
      "throttle": ""
    }
  ],
  "throttle": {
    "burstLimit": "",
    "rateLimit": ""
  },
  "quota": {
    "limit": "",
    "offset": "",
    "period": ""
  },
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/usageplans" {:content-type :json
                                                       :form-params {:name ""
                                                                     :description ""
                                                                     :apiStages [{:apiId ""
                                                                                  :stage ""
                                                                                  :throttle ""}]
                                                                     :throttle {:burstLimit ""
                                                                                :rateLimit ""}
                                                                     :quota {:limit ""
                                                                             :offset ""
                                                                             :period ""}
                                                                     :tags {}}})

require "http/client"

url = "{{baseUrl}}/usageplans"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/usageplans"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\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}}/usageplans");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}")

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

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

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

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

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

}

POST /baseUrl/usageplans HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 277

{
  "name": "",
  "description": "",
  "apiStages": [
    {
      "apiId": "",
      "stage": "",
      "throttle": ""
    }
  ],
  "throttle": {
    "burstLimit": "",
    "rateLimit": ""
  },
  "quota": {
    "limit": "",
    "offset": "",
    "period": ""
  },
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/usageplans")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/usageplans"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\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  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/usageplans")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/usageplans")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  description: '',
  apiStages: [
    {
      apiId: '',
      stage: '',
      throttle: ''
    }
  ],
  throttle: {
    burstLimit: '',
    rateLimit: ''
  },
  quota: {
    limit: '',
    offset: '',
    period: ''
  },
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/usageplans',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    description: '',
    apiStages: [{apiId: '', stage: '', throttle: ''}],
    throttle: {burstLimit: '', rateLimit: ''},
    quota: {limit: '', offset: '', period: ''},
    tags: {}
  }
};

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

const url = '{{baseUrl}}/usageplans';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","description":"","apiStages":[{"apiId":"","stage":"","throttle":""}],"throttle":{"burstLimit":"","rateLimit":""},"quota":{"limit":"","offset":"","period":""},"tags":{}}'
};

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}}/usageplans',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "description": "",\n  "apiStages": [\n    {\n      "apiId": "",\n      "stage": "",\n      "throttle": ""\n    }\n  ],\n  "throttle": {\n    "burstLimit": "",\n    "rateLimit": ""\n  },\n  "quota": {\n    "limit": "",\n    "offset": "",\n    "period": ""\n  },\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/usageplans")
  .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/usageplans',
  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({
  name: '',
  description: '',
  apiStages: [{apiId: '', stage: '', throttle: ''}],
  throttle: {burstLimit: '', rateLimit: ''},
  quota: {limit: '', offset: '', period: ''},
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/usageplans',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    description: '',
    apiStages: [{apiId: '', stage: '', throttle: ''}],
    throttle: {burstLimit: '', rateLimit: ''},
    quota: {limit: '', offset: '', period: ''},
    tags: {}
  },
  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}}/usageplans');

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

req.type('json');
req.send({
  name: '',
  description: '',
  apiStages: [
    {
      apiId: '',
      stage: '',
      throttle: ''
    }
  ],
  throttle: {
    burstLimit: '',
    rateLimit: ''
  },
  quota: {
    limit: '',
    offset: '',
    period: ''
  },
  tags: {}
});

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}}/usageplans',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    description: '',
    apiStages: [{apiId: '', stage: '', throttle: ''}],
    throttle: {burstLimit: '', rateLimit: ''},
    quota: {limit: '', offset: '', period: ''},
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/usageplans';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","description":"","apiStages":[{"apiId":"","stage":"","throttle":""}],"throttle":{"burstLimit":"","rateLimit":""},"quota":{"limit":"","offset":"","period":""},"tags":{}}'
};

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 = @{ @"name": @"",
                              @"description": @"",
                              @"apiStages": @[ @{ @"apiId": @"", @"stage": @"", @"throttle": @"" } ],
                              @"throttle": @{ @"burstLimit": @"", @"rateLimit": @"" },
                              @"quota": @{ @"limit": @"", @"offset": @"", @"period": @"" },
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/usageplans"]
                                                       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}}/usageplans" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/usageplans",
  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([
    'name' => '',
    'description' => '',
    'apiStages' => [
        [
                'apiId' => '',
                'stage' => '',
                'throttle' => ''
        ]
    ],
    'throttle' => [
        'burstLimit' => '',
        'rateLimit' => ''
    ],
    'quota' => [
        'limit' => '',
        'offset' => '',
        'period' => ''
    ],
    'tags' => [
        
    ]
  ]),
  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}}/usageplans', [
  'body' => '{
  "name": "",
  "description": "",
  "apiStages": [
    {
      "apiId": "",
      "stage": "",
      "throttle": ""
    }
  ],
  "throttle": {
    "burstLimit": "",
    "rateLimit": ""
  },
  "quota": {
    "limit": "",
    "offset": "",
    "period": ""
  },
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'description' => '',
  'apiStages' => [
    [
        'apiId' => '',
        'stage' => '',
        'throttle' => ''
    ]
  ],
  'throttle' => [
    'burstLimit' => '',
    'rateLimit' => ''
  ],
  'quota' => [
    'limit' => '',
    'offset' => '',
    'period' => ''
  ],
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'name' => '',
  'description' => '',
  'apiStages' => [
    [
        'apiId' => '',
        'stage' => '',
        'throttle' => ''
    ]
  ],
  'throttle' => [
    'burstLimit' => '',
    'rateLimit' => ''
  ],
  'quota' => [
    'limit' => '',
    'offset' => '',
    'period' => ''
  ],
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/usageplans');
$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}}/usageplans' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "description": "",
  "apiStages": [
    {
      "apiId": "",
      "stage": "",
      "throttle": ""
    }
  ],
  "throttle": {
    "burstLimit": "",
    "rateLimit": ""
  },
  "quota": {
    "limit": "",
    "offset": "",
    "period": ""
  },
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/usageplans' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "description": "",
  "apiStages": [
    {
      "apiId": "",
      "stage": "",
      "throttle": ""
    }
  ],
  "throttle": {
    "burstLimit": "",
    "rateLimit": ""
  },
  "quota": {
    "limit": "",
    "offset": "",
    "period": ""
  },
  "tags": {}
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/usageplans"

payload = {
    "name": "",
    "description": "",
    "apiStages": [
        {
            "apiId": "",
            "stage": "",
            "throttle": ""
        }
    ],
    "throttle": {
        "burstLimit": "",
        "rateLimit": ""
    },
    "quota": {
        "limit": "",
        "offset": "",
        "period": ""
    },
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/usageplans') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"apiStages\": [\n    {\n      \"apiId\": \"\",\n      \"stage\": \"\",\n      \"throttle\": \"\"\n    }\n  ],\n  \"throttle\": {\n    \"burstLimit\": \"\",\n    \"rateLimit\": \"\"\n  },\n  \"quota\": {\n    \"limit\": \"\",\n    \"offset\": \"\",\n    \"period\": \"\"\n  },\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "name": "",
        "description": "",
        "apiStages": (
            json!({
                "apiId": "",
                "stage": "",
                "throttle": ""
            })
        ),
        "throttle": json!({
            "burstLimit": "",
            "rateLimit": ""
        }),
        "quota": json!({
            "limit": "",
            "offset": "",
            "period": ""
        }),
        "tags": 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}}/usageplans \
  --header 'content-type: application/json' \
  --data '{
  "name": "",
  "description": "",
  "apiStages": [
    {
      "apiId": "",
      "stage": "",
      "throttle": ""
    }
  ],
  "throttle": {
    "burstLimit": "",
    "rateLimit": ""
  },
  "quota": {
    "limit": "",
    "offset": "",
    "period": ""
  },
  "tags": {}
}'

echo '{
  "name": "",
  "description": "",
  "apiStages": [
    {
      "apiId": "",
      "stage": "",
      "throttle": ""
    }
  ],
  "throttle": {
    "burstLimit": "",
    "rateLimit": ""
  },
  "quota": {
    "limit": "",
    "offset": "",
    "period": ""
  },
  "tags": {}
}' |  \
  http POST {{baseUrl}}/usageplans \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "description": "",\n  "apiStages": [\n    {\n      "apiId": "",\n      "stage": "",\n      "throttle": ""\n    }\n  ],\n  "throttle": {\n    "burstLimit": "",\n    "rateLimit": ""\n  },\n  "quota": {\n    "limit": "",\n    "offset": "",\n    "period": ""\n  },\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/usageplans

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "description": "",
  "apiStages": [
    [
      "apiId": "",
      "stage": "",
      "throttle": ""
    ]
  ],
  "throttle": [
    "burstLimit": "",
    "rateLimit": ""
  ],
  "quota": [
    "limit": "",
    "offset": "",
    "period": ""
  ],
  "tags": []
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateUsagePlanKey

{{baseUrl}}/usageplans/:usageplanId/keys

QUERY PARAMS

usageplanId

BODY json

{
  "keyId": "",
  "keyType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usageplans/:usageplanId/keys");

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  \"keyId\": \"\",\n  \"keyType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/usageplans/:usageplanId/keys" {:content-type :json
                                                                         :form-params {:keyId ""
                                                                                       :keyType ""}})

require "http/client"

url = "{{baseUrl}}/usageplans/:usageplanId/keys"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"keyId\": \"\",\n  \"keyType\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/usageplans/:usageplanId/keys"),
    Content = new StringContent("{\n  \"keyId\": \"\",\n  \"keyType\": \"\"\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}}/usageplans/:usageplanId/keys");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"keyId\": \"\",\n  \"keyType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/usageplans/:usageplanId/keys"

	payload := strings.NewReader("{\n  \"keyId\": \"\",\n  \"keyType\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/usageplans/:usageplanId/keys HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "keyId": "",
  "keyType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/usageplans/:usageplanId/keys")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"keyId\": \"\",\n  \"keyType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/usageplans/:usageplanId/keys")
  .header("content-type", "application/json")
  .body("{\n  \"keyId\": \"\",\n  \"keyType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  keyId: '',
  keyType: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/usageplans/:usageplanId/keys');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/usageplans/:usageplanId/keys',
  headers: {'content-type': 'application/json'},
  data: {keyId: '', keyType: ''}
};

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

const url = '{{baseUrl}}/usageplans/:usageplanId/keys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"keyId":"","keyType":""}'
};

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}}/usageplans/:usageplanId/keys',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "keyId": "",\n  "keyType": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/usageplans/:usageplanId/keys',
  headers: {'content-type': 'application/json'},
  body: {keyId: '', keyType: ''},
  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}}/usageplans/:usageplanId/keys');

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

req.type('json');
req.send({
  keyId: '',
  keyType: ''
});

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}}/usageplans/:usageplanId/keys',
  headers: {'content-type': 'application/json'},
  data: {keyId: '', keyType: ''}
};

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

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

const url = '{{baseUrl}}/usageplans/:usageplanId/keys';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"keyId":"","keyType":""}'
};

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

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

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

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

 "{{baseUrl}}/usageplans/:usageplanId/keys",
  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([
    'keyId' => '',
    'keyType' => ''
  ]),
  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}}/usageplans/:usageplanId/keys', [
  'body' => '{
  "keyId": "",
  "keyType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/usageplans/:usageplanId/keys');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'keyId' => '',
  'keyType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/usageplans/:usageplanId/keys');
$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}}/usageplans/:usageplanId/keys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "keyId": "",
  "keyType": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/usageplans/:usageplanId/keys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "keyId": "",
  "keyType": ""
}'

import http.client

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

payload = "{\n  \"keyId\": \"\",\n  \"keyType\": \"\"\n}"

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

conn.request("POST", "/baseUrl/usageplans/:usageplanId/keys", payload, headers)

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

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

import requests

url = "{{baseUrl}}/usageplans/:usageplanId/keys"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/usageplans/:usageplanId/keys"

payload <- "{\n  \"keyId\": \"\",\n  \"keyType\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/usageplans/:usageplanId/keys")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"keyId\": \"\",\n  \"keyType\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/usageplans/:usageplanId/keys') do |req|
  req.body = "{\n  \"keyId\": \"\",\n  \"keyType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "keyId": "",
        "keyType": ""
    });

    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}}/usageplans/:usageplanId/keys \
  --header 'content-type: application/json' \
  --data '{
  "keyId": "",
  "keyType": ""
}'

echo '{
  "keyId": "",
  "keyType": ""
}' |  \
  http POST {{baseUrl}}/usageplans/:usageplanId/keys \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "keyId": "",\n  "keyType": ""\n}' \
  --output-document \
  - {{baseUrl}}/usageplans/:usageplanId/keys

import Foundation

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

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

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

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

dataTask.resume()

POST CreateVpcLink

{{baseUrl}}/vpclinks

BODY json

{
  "name": "",
  "description": "",
  "targetArns": [],
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"name\": \"\",\n  \"description\": \"\",\n  \"targetArns\": [],\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/vpclinks" {:content-type :json
                                                     :form-params {:name ""
                                                                   :description ""
                                                                   :targetArns []
                                                                   :tags {}}})

require "http/client"

url = "{{baseUrl}}/vpclinks"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"targetArns\": [],\n  \"tags\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/vpclinks"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"targetArns\": [],\n  \"tags\": {}\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}}/vpclinks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"targetArns\": [],\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"targetArns\": [],\n  \"tags\": {}\n}")

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

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

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

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

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

}

POST /baseUrl/vpclinks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "name": "",
  "description": "",
  "targetArns": [],
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vpclinks")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"targetArns\": [],\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/vpclinks")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"targetArns\": [],\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  description: '',
  targetArns: [],
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vpclinks',
  headers: {'content-type': 'application/json'},
  data: {name: '', description: '', targetArns: [], tags: {}}
};

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

const url = '{{baseUrl}}/vpclinks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","description":"","targetArns":[],"tags":{}}'
};

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}}/vpclinks',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "description": "",\n  "targetArns": [],\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vpclinks',
  headers: {'content-type': 'application/json'},
  body: {name: '', description: '', targetArns: [], tags: {}},
  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}}/vpclinks');

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

req.type('json');
req.send({
  name: '',
  description: '',
  targetArns: [],
  tags: {}
});

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}}/vpclinks',
  headers: {'content-type': 'application/json'},
  data: {name: '', description: '', targetArns: [], tags: {}}
};

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

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

const url = '{{baseUrl}}/vpclinks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","description":"","targetArns":[],"tags":{}}'
};

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 = @{ @"name": @"",
                              @"description": @"",
                              @"targetArns": @[  ],
                              @"tags": @{  } };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'description' => '',
  'targetArns' => [
    
  ],
  'tags' => [
    
  ]
]));

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

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

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

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vpclinks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "description": "",
  "targetArns": [],
  "tags": {}
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"targetArns\": [],\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/vpclinks"

payload = {
    "name": "",
    "description": "",
    "targetArns": [],
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"targetArns\": [],\n  \"tags\": {}\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"targetArns\": [],\n  \"tags\": {}\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/vpclinks') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"targetArns\": [],\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "name": "",
        "description": "",
        "targetArns": (),
        "tags": 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}}/vpclinks \
  --header 'content-type: application/json' \
  --data '{
  "name": "",
  "description": "",
  "targetArns": [],
  "tags": {}
}'

echo '{
  "name": "",
  "description": "",
  "targetArns": [],
  "tags": {}
}' |  \
  http POST {{baseUrl}}/vpclinks \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "description": "",\n  "targetArns": [],\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/vpclinks

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "description": "",
  "targetArns": [],
  "tags": []
] as [String : Any]

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

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

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

dataTask.resume()

DELETE DeleteApiKey

{{baseUrl}}/apikeys/:api_Key

QUERY PARAMS

api_Key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/apikeys/:api_Key");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/apikeys/:api_Key")

require "http/client"

url = "{{baseUrl}}/apikeys/:api_Key"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/apikeys/:api_Key"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/apikeys/:api_Key'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/apikeys/:api_Key');

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}}/apikeys/:api_Key'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/apikeys/:api_Key' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/apikeys/:api_Key' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/apikeys/:api_Key")

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

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

import requests

url = "{{baseUrl}}/apikeys/:api_Key"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/apikeys/:api_Key"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/apikeys/:api_Key")

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/apikeys/:api_Key') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/apikeys/:api_Key

http DELETE {{baseUrl}}/apikeys/:api_Key

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/apikeys/:api_Key

import Foundation

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

DELETE DeleteAuthorizer

{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

QUERY PARAMS

restapi_id

authorizer_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

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

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

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

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

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

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

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

}

DELETE /baseUrl/restapis/:restapi_id/authorizers/:authorizer_id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id'
};

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

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/authorizers/:authorizer_id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id'
};

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

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

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id" in

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

 "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/authorizers/:authorizer_id")

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

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

import requests

url = "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/restapis/:restapi_id/authorizers/:authorizer_id') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

http DELETE {{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

import Foundation

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

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

dataTask.resume()

DELETE DeleteBasePathMapping

{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path

QUERY PARAMS

domain_name

base_path

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")

require "http/client"

url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"

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

var client = new RestClient("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"

	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/domainnames/:domain_name/basepathmappings/:base_path HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"))
    .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}}/domainnames/:domain_name/basepathmappings/:base_path")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path'
};

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

const url = '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path';
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}}/domainnames/:domain_name/basepathmappings/:base_path',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domainnames/:domain_name/basepathmappings/:base_path',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path'
};

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

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

const url = '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path';
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}}/domainnames/:domain_name/basepathmappings/:base_path"]
                                                       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}}/domainnames/:domain_name/basepathmappings/:base_path" in

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

 "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path",
  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}}/domainnames/:domain_name/basepathmappings/:base_path');

echo $response->getBody();

setUrl('{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/domainnames/:domain_name/basepathmappings/:base_path")

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

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

import requests

url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")

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/domainnames/:domain_name/basepathmappings/:base_path') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path

http DELETE {{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path

import Foundation

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

DELETE DeleteClientCertificate

{{baseUrl}}/clientcertificates/:clientcertificate_id

QUERY PARAMS

clientcertificate_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clientcertificates/:clientcertificate_id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/clientcertificates/:clientcertificate_id")

require "http/client"

url = "{{baseUrl}}/clientcertificates/:clientcertificate_id"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/clientcertificates/:clientcertificate_id"

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

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

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

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

}

DELETE /baseUrl/clientcertificates/:clientcertificate_id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/clientcertificates/:clientcertificate_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/clientcertificates/:clientcertificate_id'
};

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

const url = '{{baseUrl}}/clientcertificates/:clientcertificate_id';
const options = {method: 'DELETE'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/clientcertificates/:clientcertificate_id'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/clientcertificates/:clientcertificate_id');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/clientcertificates/:clientcertificate_id'
};

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

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

const url = '{{baseUrl}}/clientcertificates/:clientcertificate_id';
const options = {method: 'DELETE'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clientcertificates/:clientcertificate_id" in

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

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

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/clientcertificates/:clientcertificate_id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clientcertificates/:clientcertificate_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clientcertificates/:clientcertificate_id' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/clientcertificates/:clientcertificate_id")

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

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

import requests

url = "{{baseUrl}}/clientcertificates/:clientcertificate_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clientcertificates/:clientcertificate_id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clientcertificates/:clientcertificate_id")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/clientcertificates/:clientcertificate_id') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/clientcertificates/:clientcertificate_id

http DELETE {{baseUrl}}/clientcertificates/:clientcertificate_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/clientcertificates/:clientcertificate_id

import Foundation

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

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

dataTask.resume()

DELETE DeleteDeployment

{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id

QUERY PARAMS

restapi_id

deployment_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"

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

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

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"

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

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

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

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

}

DELETE /baseUrl/restapis/:restapi_id/deployments/:deployment_id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/deployments/:deployment_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/deployments/:deployment_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restapis/:restapi_id/deployments/:deployment_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id

http DELETE {{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteDocumentationPart

{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id

QUERY PARAMS

restapi_id

part_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/restapis/:restapi_id/documentation/parts/:part_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/documentation/parts/:part_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/documentation/parts/:part_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restapis/:restapi_id/documentation/parts/:part_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id

http DELETE {{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteDocumentationVersion

{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version

QUERY PARAMS

restapi_id

doc_version

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"

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}}/restapis/:restapi_id/documentation/versions/:doc_version"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"

	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/restapis/:restapi_id/documentation/versions/:doc_version HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"))
    .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}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .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}}/restapis/:restapi_id/documentation/versions/:doc_version');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version';
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}}/restapis/:restapi_id/documentation/versions/:doc_version',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/documentation/versions/:doc_version',
  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}}/restapis/:restapi_id/documentation/versions/:doc_version'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version');

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}}/restapis/:restapi_id/documentation/versions/:doc_version'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version';
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}}/restapis/:restapi_id/documentation/versions/:doc_version"]
                                                       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}}/restapis/:restapi_id/documentation/versions/:doc_version" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version",
  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}}/restapis/:restapi_id/documentation/versions/:doc_version');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/documentation/versions/:doc_version")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")

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/restapis/:restapi_id/documentation/versions/:doc_version') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version

http DELETE {{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")! 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()

DELETE DeleteDomainName

{{baseUrl}}/domainnames/:domain_name

QUERY PARAMS

domain_name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domainnames/:domain_name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/domainnames/:domain_name")

require "http/client"

url = "{{baseUrl}}/domainnames/:domain_name"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/domainnames/:domain_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domainnames/:domain_name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domainnames/:domain_name"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/domainnames/:domain_name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/domainnames/:domain_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domainnames/:domain_name"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/domainnames/:domain_name")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/domainnames/:domain_name');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/domainnames/:domain_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domainnames/:domain_name';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domainnames/:domain_name',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domainnames/:domain_name',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/domainnames/:domain_name'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/domainnames/:domain_name');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/domainnames/:domain_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domainnames/:domain_name';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domainnames/:domain_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domainnames/:domain_name" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domainnames/:domain_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/domainnames/:domain_name');

echo $response->getBody();

setUrl('{{baseUrl}}/domainnames/:domain_name');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/domainnames/:domain_name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domainnames/:domain_name' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainnames/:domain_name' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/domainnames/:domain_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domainnames/:domain_name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domainnames/:domain_name"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domainnames/:domain_name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/domainnames/:domain_name') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domainnames/:domain_name";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/domainnames/:domain_name

http DELETE {{baseUrl}}/domainnames/:domain_name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/domainnames/:domain_name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domainnames/:domain_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteGatewayResponse

{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type

QUERY PARAMS

restapi_id

response_type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

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}}/restapis/:restapi_id/gatewayresponses/:response_type"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

	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/restapis/:restapi_id/gatewayresponses/:response_type HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"))
    .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}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .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}}/restapis/:restapi_id/gatewayresponses/:response_type');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type';
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}}/restapis/:restapi_id/gatewayresponses/:response_type',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/gatewayresponses/:response_type',
  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}}/restapis/:restapi_id/gatewayresponses/:response_type'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type';
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}}/restapis/:restapi_id/gatewayresponses/:response_type"]
                                                       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}}/restapis/:restapi_id/gatewayresponses/:response_type" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type",
  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}}/restapis/:restapi_id/gatewayresponses/:response_type');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/gatewayresponses/:response_type")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")

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/restapis/:restapi_id/gatewayresponses/:response_type') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type

http DELETE {{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")! 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()

DELETE DeleteIntegration

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

QUERY PARAMS

restapi_id

resource_id

http_method

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

	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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"))
    .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration",
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")

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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

http DELETE {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")! 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()

DELETE DeleteIntegrationResponse

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

QUERY PARAMS

restapi_id

resource_id

http_method

status_code

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

	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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"))
    .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code",
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")

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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

http DELETE {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")! 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()

DELETE DeleteMethod

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

QUERY PARAMS

restapi_id

resource_id

http_method

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

	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/restapis/:restapi_id/resources/:resource_id/methods/:http_method HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"))
    .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method",
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")

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/restapis/:restapi_id/resources/:resource_id/methods/:http_method') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

http DELETE {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")! 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()

DELETE DeleteMethodResponse

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

QUERY PARAMS

restapi_id

resource_id

http_method

status_code

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

	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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"))
    .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code",
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")

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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

http DELETE {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")! 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()

DELETE DeleteModel

{{baseUrl}}/restapis/:restapi_id/models/:model_name

QUERY PARAMS

restapi_id

model_name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/models/:model_name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/models/:model_name")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/models/:model_name"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/models/:model_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/models/:model_name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/models/:model_name"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/restapis/:restapi_id/models/:model_name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/models/:model_name"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restapis/:restapi_id/models/:model_name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/models/:model_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/models/:model_name';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/models/:model_name',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/models/:model_name',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/models/:model_name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/models/:model_name');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/models/:model_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/models/:model_name';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/models/:model_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/models/:model_name" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/models/:model_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restapis/:restapi_id/models/:model_name');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/models/:model_name');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/models/:model_name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/models/:model_name' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/models/:model_name' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/models/:model_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/models/:model_name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/models/:model_name"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/models/:model_name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restapis/:restapi_id/models/:model_name') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/models/:model_name";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/models/:model_name

http DELETE {{baseUrl}}/restapis/:restapi_id/models/:model_name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/models/:model_name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/models/:model_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteRequestValidator

{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id

QUERY PARAMS

restapi_id

requestvalidator_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/restapis/:restapi_id/requestvalidators/:requestvalidator_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/requestvalidators/:requestvalidator_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/requestvalidators/:requestvalidator_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restapis/:restapi_id/requestvalidators/:requestvalidator_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id

http DELETE {{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteResource

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id

QUERY PARAMS

restapi_id

resource_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/restapis/:restapi_id/resources/:resource_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources/:resource_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/resources/:resource_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restapis/:restapi_id/resources/:resource_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/resources/:resource_id

http DELETE {{baseUrl}}/restapis/:restapi_id/resources/:resource_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteRestApi

{{baseUrl}}/restapis/:restapi_id

QUERY PARAMS

restapi_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/restapis/:restapi_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restapis/:restapi_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/restapis/:restapi_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/restapis/:restapi_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/restapis/:restapi_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restapis/:restapi_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restapis/:restapi_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id

http DELETE {{baseUrl}}/restapis/:restapi_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteStage

{{baseUrl}}/restapis/:restapi_id/stages/:stage_name

QUERY PARAMS

restapi_id

stage_name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/restapis/:restapi_id/stages/:stage_name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/stages/:stage_name',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/stages/:stage_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/restapis/:restapi_id/stages/:stage_name') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/stages/:stage_name

http DELETE {{baseUrl}}/restapis/:restapi_id/stages/:stage_name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/stages/:stage_name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE DeleteUsagePlan

{{baseUrl}}/usageplans/:usageplanId

QUERY PARAMS

usageplanId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usageplans/:usageplanId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/usageplans/:usageplanId")

require "http/client"

url = "{{baseUrl}}/usageplans/:usageplanId"

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}}/usageplans/:usageplanId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/usageplans/:usageplanId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/usageplans/:usageplanId"

	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/usageplans/:usageplanId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/usageplans/:usageplanId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/usageplans/:usageplanId"))
    .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}}/usageplans/:usageplanId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/usageplans/:usageplanId")
  .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}}/usageplans/:usageplanId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/usageplans/:usageplanId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/usageplans/:usageplanId';
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}}/usageplans/:usageplanId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/usageplans/:usageplanId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/usageplans/:usageplanId',
  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}}/usageplans/:usageplanId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/usageplans/:usageplanId');

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}}/usageplans/:usageplanId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/usageplans/:usageplanId';
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}}/usageplans/:usageplanId"]
                                                       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}}/usageplans/:usageplanId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/usageplans/:usageplanId",
  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}}/usageplans/:usageplanId');

echo $response->getBody();

setUrl('{{baseUrl}}/usageplans/:usageplanId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/usageplans/:usageplanId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/usageplans/:usageplanId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/usageplans/:usageplanId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/usageplans/:usageplanId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/usageplans/:usageplanId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/usageplans/:usageplanId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/usageplans/:usageplanId")

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/usageplans/:usageplanId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/usageplans/:usageplanId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/usageplans/:usageplanId

http DELETE {{baseUrl}}/usageplans/:usageplanId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/usageplans/:usageplanId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usageplans/:usageplanId")! 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()

DELETE DeleteUsagePlanKey

{{baseUrl}}/usageplans/:usageplanId/keys/:keyId

QUERY PARAMS

usageplanId

keyId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")

require "http/client"

url = "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId"

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}}/usageplans/:usageplanId/keys/:keyId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId"

	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/usageplans/:usageplanId/keys/:keyId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId"))
    .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}}/usageplans/:usageplanId/keys/:keyId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")
  .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}}/usageplans/:usageplanId/keys/:keyId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId';
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}}/usageplans/:usageplanId/keys/:keyId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/usageplans/:usageplanId/keys/:keyId',
  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}}/usageplans/:usageplanId/keys/:keyId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId');

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}}/usageplans/:usageplanId/keys/:keyId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId';
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}}/usageplans/:usageplanId/keys/:keyId"]
                                                       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}}/usageplans/:usageplanId/keys/:keyId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId",
  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}}/usageplans/:usageplanId/keys/:keyId');

echo $response->getBody();

setUrl('{{baseUrl}}/usageplans/:usageplanId/keys/:keyId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/usageplans/:usageplanId/keys/:keyId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/usageplans/:usageplanId/keys/:keyId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")

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/usageplans/:usageplanId/keys/:keyId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/usageplans/:usageplanId/keys/:keyId

http DELETE {{baseUrl}}/usageplans/:usageplanId/keys/:keyId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/usageplans/:usageplanId/keys/:keyId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")! 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()

DELETE DeleteVpcLink

{{baseUrl}}/vpclinks/:vpclink_id

QUERY PARAMS

vpclink_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vpclinks/:vpclink_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/vpclinks/:vpclink_id")

require "http/client"

url = "{{baseUrl}}/vpclinks/:vpclink_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/vpclinks/:vpclink_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/vpclinks/:vpclink_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vpclinks/:vpclink_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/vpclinks/:vpclink_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/vpclinks/:vpclink_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vpclinks/:vpclink_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vpclinks/:vpclink_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/vpclinks/:vpclink_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/vpclinks/:vpclink_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/vpclinks/:vpclink_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/vpclinks/:vpclink_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vpclinks/:vpclink_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vpclinks/:vpclink_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vpclinks/:vpclink_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/vpclinks/:vpclink_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/vpclinks/:vpclink_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/vpclinks/:vpclink_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/vpclinks/:vpclink_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vpclinks/:vpclink_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vpclinks/:vpclink_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/vpclinks/:vpclink_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/vpclinks/:vpclink_id');

echo $response->getBody();

setUrl('{{baseUrl}}/vpclinks/:vpclink_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/vpclinks/:vpclink_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/vpclinks/:vpclink_id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/vpclinks/:vpclink_id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/vpclinks/:vpclink_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/vpclinks/:vpclink_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/vpclinks/:vpclink_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vpclinks/:vpclink_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/vpclinks/:vpclink_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vpclinks/:vpclink_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/vpclinks/:vpclink_id

http DELETE {{baseUrl}}/vpclinks/:vpclink_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/vpclinks/:vpclink_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vpclinks/:vpclink_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE FlushStageAuthorizersCache

{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers

QUERY PARAMS

restapi_id

stage_name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers"

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}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers"

	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/restapis/:restapi_id/stages/:stage_name/cache/authorizers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers"))
    .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}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers")
  .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}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers';
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}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/stages/:stage_name/cache/authorizers',
  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}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers');

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}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers';
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}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers"]
                                                       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}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers",
  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}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/stages/:stage_name/cache/authorizers")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers")

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/restapis/:restapi_id/stages/:stage_name/cache/authorizers') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers

http DELETE {{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/authorizers")! 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()

DELETE FlushStageCache

{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data

QUERY PARAMS

restapi_id

stage_name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data"

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}}/restapis/:restapi_id/stages/:stage_name/cache/data"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data"

	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/restapis/:restapi_id/stages/:stage_name/cache/data HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data"))
    .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}}/restapis/:restapi_id/stages/:stage_name/cache/data")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data")
  .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}}/restapis/:restapi_id/stages/:stage_name/cache/data');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data';
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}}/restapis/:restapi_id/stages/:stage_name/cache/data',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/stages/:stage_name/cache/data',
  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}}/restapis/:restapi_id/stages/:stage_name/cache/data'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data');

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}}/restapis/:restapi_id/stages/:stage_name/cache/data'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data';
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}}/restapis/:restapi_id/stages/:stage_name/cache/data"]
                                                       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}}/restapis/:restapi_id/stages/:stage_name/cache/data" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data",
  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}}/restapis/:restapi_id/stages/:stage_name/cache/data');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/restapis/:restapi_id/stages/:stage_name/cache/data")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data")

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/restapis/:restapi_id/stages/:stage_name/cache/data') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data

http DELETE {{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/cache/data")! 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 GenerateClientCertificate

{{baseUrl}}/clientcertificates

BODY json

{
  "description": "",
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clientcertificates");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/clientcertificates" {:content-type :json
                                                               :form-params {:description ""
                                                                             :tags {}}})

require "http/client"

url = "{{baseUrl}}/clientcertificates"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"tags\": {}\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/clientcertificates"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"tags\": {}\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}}/clientcertificates");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clientcertificates"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"tags\": {}\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/clientcertificates HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "description": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clientcertificates")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clientcertificates"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clientcertificates")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/clientcertificates")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  tags: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/clientcertificates');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clientcertificates',
  headers: {'content-type': 'application/json'},
  data: {description: '', tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clientcertificates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","tags":{}}'
};

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}}/clientcertificates',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "tags": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clientcertificates")
  .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/clientcertificates',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({description: '', tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clientcertificates',
  headers: {'content-type': 'application/json'},
  body: {description: '', tags: {}},
  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}}/clientcertificates');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  tags: {}
});

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}}/clientcertificates',
  headers: {'content-type': 'application/json'},
  data: {description: '', tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clientcertificates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clientcertificates"]
                                                       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}}/clientcertificates" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"tags\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clientcertificates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'description' => '',
    'tags' => [
        
    ]
  ]),
  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}}/clientcertificates', [
  'body' => '{
  "description": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clientcertificates');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/clientcertificates');
$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}}/clientcertificates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clientcertificates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/clientcertificates", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clientcertificates"

payload = {
    "description": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clientcertificates"

payload <- "{\n  \"description\": \"\",\n  \"tags\": {}\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clientcertificates")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"description\": \"\",\n  \"tags\": {}\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/clientcertificates') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clientcertificates";

    let payload = json!({
        "description": "",
        "tags": 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}}/clientcertificates \
  --header 'content-type: application/json' \
  --data '{
  "description": "",
  "tags": {}
}'

echo '{
  "description": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/clientcertificates \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/clientcertificates

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "tags": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clientcertificates")! 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 GetAccount

{{baseUrl}}/account

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/account")

require "http/client"

url = "{{baseUrl}}/account"

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}}/account"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account"

	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/account HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/account")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account"))
    .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}}/account")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/account")
  .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}}/account');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/account'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account';
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}}/account',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/account")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/account',
  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}}/account'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account');

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}}/account'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account';
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}}/account"]
                                                       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}}/account" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account",
  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}}/account');

echo $response->getBody();

setUrl('{{baseUrl}}/account');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/account');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/account' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/account' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/account")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account")

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/account') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account";

    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}}/account

http GET {{baseUrl}}/account

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/account

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account")! 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 GetApiKey

{{baseUrl}}/apikeys/:api_Key

QUERY PARAMS

api_Key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/apikeys/:api_Key");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/apikeys/:api_Key")

require "http/client"

url = "{{baseUrl}}/apikeys/:api_Key"

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}}/apikeys/:api_Key"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/apikeys/:api_Key");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/apikeys/:api_Key"

	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/apikeys/:api_Key HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/apikeys/:api_Key")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/apikeys/:api_Key"))
    .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}}/apikeys/:api_Key")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/apikeys/:api_Key")
  .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}}/apikeys/:api_Key');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/apikeys/:api_Key'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/apikeys/:api_Key';
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}}/apikeys/:api_Key',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/apikeys/:api_Key")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/apikeys/:api_Key',
  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}}/apikeys/:api_Key'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/apikeys/:api_Key');

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}}/apikeys/:api_Key'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/apikeys/:api_Key';
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}}/apikeys/:api_Key"]
                                                       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}}/apikeys/:api_Key" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/apikeys/:api_Key",
  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}}/apikeys/:api_Key');

echo $response->getBody();

setUrl('{{baseUrl}}/apikeys/:api_Key');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/apikeys/:api_Key');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/apikeys/:api_Key' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/apikeys/:api_Key' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/apikeys/:api_Key")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/apikeys/:api_Key"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/apikeys/:api_Key"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/apikeys/:api_Key")

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/apikeys/:api_Key') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/apikeys/:api_Key";

    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}}/apikeys/:api_Key

http GET {{baseUrl}}/apikeys/:api_Key

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/apikeys/:api_Key

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/apikeys/:api_Key")! 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 GetApiKeys

{{baseUrl}}/apikeys

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/apikeys");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/apikeys")

require "http/client"

url = "{{baseUrl}}/apikeys"

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}}/apikeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/apikeys");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/apikeys"

	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/apikeys HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/apikeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/apikeys"))
    .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}}/apikeys")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/apikeys")
  .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}}/apikeys');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/apikeys'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/apikeys';
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}}/apikeys',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/apikeys")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/apikeys',
  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}}/apikeys'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/apikeys');

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}}/apikeys'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/apikeys';
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}}/apikeys"]
                                                       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}}/apikeys" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/apikeys",
  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}}/apikeys');

echo $response->getBody();

setUrl('{{baseUrl}}/apikeys');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/apikeys');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/apikeys' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/apikeys' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/apikeys")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/apikeys"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/apikeys"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/apikeys")

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/apikeys') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/apikeys";

    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}}/apikeys

http GET {{baseUrl}}/apikeys

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/apikeys

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/apikeys")! 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 GetAuthorizer

{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

QUERY PARAMS

restapi_id

authorizer_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/restapis/:restapi_id/authorizers/:authorizer_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/authorizers/:authorizer_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/authorizers/:authorizer_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restapis/:restapi_id/authorizers/:authorizer_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

http GET {{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetAuthorizers

{{baseUrl}}/restapis/:restapi_id/authorizers

QUERY PARAMS

restapi_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/authorizers");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/authorizers")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/authorizers"

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}}/restapis/:restapi_id/authorizers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/authorizers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/authorizers"

	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/restapis/:restapi_id/authorizers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/authorizers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/authorizers"))
    .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}}/restapis/:restapi_id/authorizers")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/authorizers")
  .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}}/restapis/:restapi_id/authorizers');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers';
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}}/restapis/:restapi_id/authorizers',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/authorizers")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/authorizers',
  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}}/restapis/:restapi_id/authorizers'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/authorizers');

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}}/restapis/:restapi_id/authorizers'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers';
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}}/restapis/:restapi_id/authorizers"]
                                                       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}}/restapis/:restapi_id/authorizers" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/authorizers",
  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}}/restapis/:restapi_id/authorizers');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/authorizers');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/authorizers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/authorizers' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/authorizers' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/authorizers")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/authorizers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/authorizers"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/authorizers")

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/restapis/:restapi_id/authorizers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/authorizers";

    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}}/restapis/:restapi_id/authorizers

http GET {{baseUrl}}/restapis/:restapi_id/authorizers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/authorizers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/authorizers")! 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 GetBasePathMapping

{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path

QUERY PARAMS

domain_name

base_path

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")

require "http/client"

url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/domainnames/:domain_name/basepathmappings/:base_path HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domainnames/:domain_name/basepathmappings/:base_path',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');

echo $response->getBody();

setUrl('{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/domainnames/:domain_name/basepathmappings/:base_path")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/domainnames/:domain_name/basepathmappings/:base_path') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path";

    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}}/domainnames/:domain_name/basepathmappings/:base_path

http GET {{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetBasePathMappings

{{baseUrl}}/domainnames/:domain_name/basepathmappings

QUERY PARAMS

domain_name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domainnames/:domain_name/basepathmappings");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/domainnames/:domain_name/basepathmappings")

require "http/client"

url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings"

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}}/domainnames/:domain_name/basepathmappings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domainnames/:domain_name/basepathmappings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domainnames/:domain_name/basepathmappings"

	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/domainnames/:domain_name/basepathmappings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domainnames/:domain_name/basepathmappings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domainnames/:domain_name/basepathmappings"))
    .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}}/domainnames/:domain_name/basepathmappings")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/domainnames/:domain_name/basepathmappings")
  .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}}/domainnames/:domain_name/basepathmappings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domainnames/:domain_name/basepathmappings';
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}}/domainnames/:domain_name/basepathmappings',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name/basepathmappings")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domainnames/:domain_name/basepathmappings',
  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}}/domainnames/:domain_name/basepathmappings'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domainnames/:domain_name/basepathmappings');

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}}/domainnames/:domain_name/basepathmappings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domainnames/:domain_name/basepathmappings';
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}}/domainnames/:domain_name/basepathmappings"]
                                                       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}}/domainnames/:domain_name/basepathmappings" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domainnames/:domain_name/basepathmappings",
  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}}/domainnames/:domain_name/basepathmappings');

echo $response->getBody();

setUrl('{{baseUrl}}/domainnames/:domain_name/basepathmappings');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/domainnames/:domain_name/basepathmappings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domainnames/:domain_name/basepathmappings' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainnames/:domain_name/basepathmappings' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/domainnames/:domain_name/basepathmappings")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domainnames/:domain_name/basepathmappings"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domainnames/:domain_name/basepathmappings")

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/domainnames/:domain_name/basepathmappings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings";

    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}}/domainnames/:domain_name/basepathmappings

http GET {{baseUrl}}/domainnames/:domain_name/basepathmappings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domainnames/:domain_name/basepathmappings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domainnames/:domain_name/basepathmappings")! 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 GetClientCertificate

{{baseUrl}}/clientcertificates/:clientcertificate_id

QUERY PARAMS

clientcertificate_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clientcertificates/:clientcertificate_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/clientcertificates/:clientcertificate_id")

require "http/client"

url = "{{baseUrl}}/clientcertificates/:clientcertificate_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/clientcertificates/:clientcertificate_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clientcertificates/:clientcertificate_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clientcertificates/:clientcertificate_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/clientcertificates/:clientcertificate_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/clientcertificates/:clientcertificate_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clientcertificates/:clientcertificate_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/clientcertificates/:clientcertificate_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/clientcertificates/:clientcertificate_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/clientcertificates/:clientcertificate_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clientcertificates/:clientcertificate_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clientcertificates/:clientcertificate_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clientcertificates/:clientcertificate_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clientcertificates/:clientcertificate_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clientcertificates/:clientcertificate_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clientcertificates/:clientcertificate_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clientcertificates/:clientcertificate_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clientcertificates/:clientcertificate_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clientcertificates/:clientcertificate_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clientcertificates/:clientcertificate_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clientcertificates/:clientcertificate_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clientcertificates/:clientcertificate_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/clientcertificates/:clientcertificate_id');

echo $response->getBody();

setUrl('{{baseUrl}}/clientcertificates/:clientcertificate_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/clientcertificates/:clientcertificate_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clientcertificates/:clientcertificate_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clientcertificates/:clientcertificate_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/clientcertificates/:clientcertificate_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clientcertificates/:clientcertificate_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clientcertificates/:clientcertificate_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clientcertificates/:clientcertificate_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/clientcertificates/:clientcertificate_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clientcertificates/:clientcertificate_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/clientcertificates/:clientcertificate_id

http GET {{baseUrl}}/clientcertificates/:clientcertificate_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clientcertificates/:clientcertificate_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clientcertificates/:clientcertificate_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetClientCertificates

{{baseUrl}}/clientcertificates

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clientcertificates");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/clientcertificates")

require "http/client"

url = "{{baseUrl}}/clientcertificates"

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}}/clientcertificates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clientcertificates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clientcertificates"

	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/clientcertificates HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/clientcertificates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clientcertificates"))
    .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}}/clientcertificates")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/clientcertificates")
  .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}}/clientcertificates');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/clientcertificates'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clientcertificates';
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}}/clientcertificates',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clientcertificates")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clientcertificates',
  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}}/clientcertificates'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clientcertificates');

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}}/clientcertificates'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clientcertificates';
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}}/clientcertificates"]
                                                       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}}/clientcertificates" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clientcertificates",
  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}}/clientcertificates');

echo $response->getBody();

setUrl('{{baseUrl}}/clientcertificates');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/clientcertificates');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clientcertificates' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clientcertificates' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/clientcertificates")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clientcertificates"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clientcertificates"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clientcertificates")

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/clientcertificates') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clientcertificates";

    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}}/clientcertificates

http GET {{baseUrl}}/clientcertificates

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clientcertificates

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clientcertificates")! 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 GetDeployment

{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id

QUERY PARAMS

restapi_id

deployment_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/restapis/:restapi_id/deployments/:deployment_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/deployments/:deployment_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/deployments/:deployment_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restapis/:restapi_id/deployments/:deployment_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id

http GET {{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetDeployments

{{baseUrl}}/restapis/:restapi_id/deployments

QUERY PARAMS

restapi_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/deployments");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/deployments")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/deployments"

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}}/restapis/:restapi_id/deployments"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/deployments");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/deployments"

	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/restapis/:restapi_id/deployments HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/deployments")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/deployments"))
    .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}}/restapis/:restapi_id/deployments")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/deployments")
  .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}}/restapis/:restapi_id/deployments');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/deployments';
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}}/restapis/:restapi_id/deployments',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/deployments")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/deployments',
  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}}/restapis/:restapi_id/deployments'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/deployments');

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}}/restapis/:restapi_id/deployments'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/deployments';
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}}/restapis/:restapi_id/deployments"]
                                                       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}}/restapis/:restapi_id/deployments" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/deployments",
  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}}/restapis/:restapi_id/deployments');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/deployments');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/deployments');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/deployments' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/deployments' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/deployments")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/deployments"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/deployments"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/deployments")

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/restapis/:restapi_id/deployments') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/deployments";

    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}}/restapis/:restapi_id/deployments

http GET {{baseUrl}}/restapis/:restapi_id/deployments

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/deployments

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/deployments")! 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 GetDocumentationPart

{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id

QUERY PARAMS

restapi_id

part_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/restapis/:restapi_id/documentation/parts/:part_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/documentation/parts/:part_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/documentation/parts/:part_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restapis/:restapi_id/documentation/parts/:part_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id

http GET {{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetDocumentationParts

{{baseUrl}}/restapis/:restapi_id/documentation/parts

QUERY PARAMS

restapi_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/documentation/parts");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/documentation/parts")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts"

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}}/restapis/:restapi_id/documentation/parts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/documentation/parts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/documentation/parts"

	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/restapis/:restapi_id/documentation/parts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/documentation/parts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/documentation/parts"))
    .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}}/restapis/:restapi_id/documentation/parts")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/documentation/parts")
  .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}}/restapis/:restapi_id/documentation/parts');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts';
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}}/restapis/:restapi_id/documentation/parts',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/parts")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/documentation/parts',
  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}}/restapis/:restapi_id/documentation/parts'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/documentation/parts');

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}}/restapis/:restapi_id/documentation/parts'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts';
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}}/restapis/:restapi_id/documentation/parts"]
                                                       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}}/restapis/:restapi_id/documentation/parts" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/documentation/parts",
  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}}/restapis/:restapi_id/documentation/parts');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/parts' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/parts' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/documentation/parts")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/documentation/parts"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/documentation/parts")

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/restapis/:restapi_id/documentation/parts') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts";

    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}}/restapis/:restapi_id/documentation/parts

http GET {{baseUrl}}/restapis/:restapi_id/documentation/parts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/documentation/parts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/documentation/parts")! 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 GetDocumentationVersion

{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version

QUERY PARAMS

restapi_id

doc_version

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"

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}}/restapis/:restapi_id/documentation/versions/:doc_version"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"

	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/restapis/:restapi_id/documentation/versions/:doc_version HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"))
    .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}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .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}}/restapis/:restapi_id/documentation/versions/:doc_version');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version';
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}}/restapis/:restapi_id/documentation/versions/:doc_version',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/documentation/versions/:doc_version',
  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}}/restapis/:restapi_id/documentation/versions/:doc_version'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version');

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}}/restapis/:restapi_id/documentation/versions/:doc_version'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version';
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}}/restapis/:restapi_id/documentation/versions/:doc_version"]
                                                       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}}/restapis/:restapi_id/documentation/versions/:doc_version" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version",
  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}}/restapis/:restapi_id/documentation/versions/:doc_version');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/documentation/versions/:doc_version")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")

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/restapis/:restapi_id/documentation/versions/:doc_version') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version";

    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}}/restapis/:restapi_id/documentation/versions/:doc_version

http GET {{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")! 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 GetDocumentationVersions

{{baseUrl}}/restapis/:restapi_id/documentation/versions

QUERY PARAMS

restapi_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/documentation/versions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/documentation/versions")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/versions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/documentation/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/documentation/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/restapis/:restapi_id/documentation/versions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/documentation/versions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/versions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/versions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/versions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/versions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/versions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/documentation/versions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/documentation/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/versions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/versions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/documentation/versions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/documentation/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/documentation/versions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/documentation/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/restapis/:restapi_id/documentation/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/documentation/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}}/restapis/:restapi_id/documentation/versions

http GET {{baseUrl}}/restapis/:restapi_id/documentation/versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/documentation/versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/documentation/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 GetDomainName

{{baseUrl}}/domainnames/:domain_name

QUERY PARAMS

domain_name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domainnames/:domain_name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/domainnames/:domain_name")

require "http/client"

url = "{{baseUrl}}/domainnames/:domain_name"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/domainnames/:domain_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domainnames/:domain_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domainnames/:domain_name"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/domainnames/:domain_name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domainnames/:domain_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domainnames/:domain_name"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/domainnames/:domain_name")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/domainnames/:domain_name');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/domainnames/:domain_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domainnames/:domain_name';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/domainnames/:domain_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domainnames/:domain_name',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/domainnames/:domain_name'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domainnames/:domain_name');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/domainnames/:domain_name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domainnames/:domain_name';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domainnames/:domain_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domainnames/:domain_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domainnames/:domain_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/domainnames/:domain_name');

echo $response->getBody();

setUrl('{{baseUrl}}/domainnames/:domain_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/domainnames/:domain_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domainnames/:domain_name' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainnames/:domain_name' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/domainnames/:domain_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domainnames/:domain_name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domainnames/:domain_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domainnames/:domain_name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/domainnames/:domain_name') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domainnames/:domain_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/domainnames/:domain_name

http GET {{baseUrl}}/domainnames/:domain_name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domainnames/:domain_name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domainnames/:domain_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetDomainNames

{{baseUrl}}/domainnames

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domainnames");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/domainnames")

require "http/client"

url = "{{baseUrl}}/domainnames"

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}}/domainnames"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domainnames");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domainnames"

	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/domainnames HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domainnames")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domainnames"))
    .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}}/domainnames")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/domainnames")
  .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}}/domainnames');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/domainnames'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domainnames';
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}}/domainnames',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domainnames")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domainnames',
  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}}/domainnames'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/domainnames');

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}}/domainnames'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domainnames';
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}}/domainnames"]
                                                       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}}/domainnames" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domainnames",
  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}}/domainnames');

echo $response->getBody();

setUrl('{{baseUrl}}/domainnames');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/domainnames');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domainnames' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainnames' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/domainnames")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domainnames"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domainnames"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domainnames")

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/domainnames') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domainnames";

    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}}/domainnames

http GET {{baseUrl}}/domainnames

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/domainnames

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domainnames")! 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 GetExport

{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type

QUERY PARAMS

restapi_id

stage_name

export_type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type"

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}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type"

	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/restapis/:restapi_id/stages/:stage_name/exports/:export_type HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type"))
    .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}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type")
  .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}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type';
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}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/stages/:stage_name/exports/:export_type',
  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}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type';
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}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type"]
                                                       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}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type",
  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}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/stages/:stage_name/exports/:export_type")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type")

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/restapis/:restapi_id/stages/:stage_name/exports/:export_type') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type";

    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}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type

http GET {{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/exports/:export_type")! 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 GetGatewayResponse

{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type

QUERY PARAMS

restapi_id

response_type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

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}}/restapis/:restapi_id/gatewayresponses/:response_type"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

	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/restapis/:restapi_id/gatewayresponses/:response_type HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"))
    .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}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .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}}/restapis/:restapi_id/gatewayresponses/:response_type');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type';
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}}/restapis/:restapi_id/gatewayresponses/:response_type',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/gatewayresponses/:response_type',
  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}}/restapis/:restapi_id/gatewayresponses/:response_type'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type';
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}}/restapis/:restapi_id/gatewayresponses/:response_type"]
                                                       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}}/restapis/:restapi_id/gatewayresponses/:response_type" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type",
  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}}/restapis/:restapi_id/gatewayresponses/:response_type');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/gatewayresponses/:response_type")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")

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/restapis/:restapi_id/gatewayresponses/:response_type') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type";

    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}}/restapis/:restapi_id/gatewayresponses/:response_type

http GET {{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")! 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 GetGatewayResponses

{{baseUrl}}/restapis/:restapi_id/gatewayresponses

QUERY PARAMS

restapi_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/gatewayresponses");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/gatewayresponses")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses"

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}}/restapis/:restapi_id/gatewayresponses"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/gatewayresponses");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/gatewayresponses"

	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/restapis/:restapi_id/gatewayresponses HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/gatewayresponses")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/gatewayresponses"))
    .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}}/restapis/:restapi_id/gatewayresponses")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/gatewayresponses")
  .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}}/restapis/:restapi_id/gatewayresponses');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/gatewayresponses'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/gatewayresponses';
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}}/restapis/:restapi_id/gatewayresponses',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/gatewayresponses")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/gatewayresponses',
  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}}/restapis/:restapi_id/gatewayresponses'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/gatewayresponses');

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}}/restapis/:restapi_id/gatewayresponses'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/gatewayresponses';
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}}/restapis/:restapi_id/gatewayresponses"]
                                                       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}}/restapis/:restapi_id/gatewayresponses" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/gatewayresponses",
  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}}/restapis/:restapi_id/gatewayresponses');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/gatewayresponses');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/gatewayresponses');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/gatewayresponses' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/gatewayresponses' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/gatewayresponses")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/gatewayresponses"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/gatewayresponses")

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/restapis/:restapi_id/gatewayresponses') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses";

    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}}/restapis/:restapi_id/gatewayresponses

http GET {{baseUrl}}/restapis/:restapi_id/gatewayresponses

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/gatewayresponses

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/gatewayresponses")! 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 GetIntegration

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

QUERY PARAMS

restapi_id

resource_id

http_method

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

	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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"))
    .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration",
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")

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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration";

    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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

http GET {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")! 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 GetIntegrationResponse

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

QUERY PARAMS

restapi_id

resource_id

http_method

status_code

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

	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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"))
    .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code",
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")

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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code";

    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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

http GET {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")! 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 GetMethod

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

QUERY PARAMS

restapi_id

resource_id

http_method

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

	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/restapis/:restapi_id/resources/:resource_id/methods/:http_method HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"))
    .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method",
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")

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/restapis/:restapi_id/resources/:resource_id/methods/:http_method') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method";

    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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

http GET {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")! 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 GetMethodResponse

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

QUERY PARAMS

restapi_id

resource_id

http_method

status_code

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

	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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"))
    .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code';
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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code",
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")

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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code";

    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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

http GET {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")! 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 GetModel

{{baseUrl}}/restapis/:restapi_id/models/:model_name

QUERY PARAMS

restapi_id

model_name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/models/:model_name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/models/:model_name")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/models/:model_name"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/models/:model_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/models/:model_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/models/:model_name"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/restapis/:restapi_id/models/:model_name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/models/:model_name"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restapis/:restapi_id/models/:model_name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/models/:model_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/models/:model_name';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/models/:model_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/models/:model_name',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/models/:model_name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/models/:model_name');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/models/:model_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/models/:model_name';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/models/:model_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/models/:model_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/models/:model_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restapis/:restapi_id/models/:model_name');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/models/:model_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/models/:model_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/models/:model_name' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/models/:model_name' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/models/:model_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/models/:model_name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/models/:model_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/models/:model_name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restapis/:restapi_id/models/:model_name') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/models/:model_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/restapis/:restapi_id/models/:model_name

http GET {{baseUrl}}/restapis/:restapi_id/models/:model_name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/models/:model_name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/models/:model_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetModelTemplate

{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template

QUERY PARAMS

restapi_id

model_name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template"

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}}/restapis/:restapi_id/models/:model_name/default_template"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template"

	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/restapis/:restapi_id/models/:model_name/default_template HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template"))
    .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}}/restapis/:restapi_id/models/:model_name/default_template")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template")
  .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}}/restapis/:restapi_id/models/:model_name/default_template');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template';
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}}/restapis/:restapi_id/models/:model_name/default_template',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/models/:model_name/default_template',
  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}}/restapis/:restapi_id/models/:model_name/default_template'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template');

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}}/restapis/:restapi_id/models/:model_name/default_template'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template';
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}}/restapis/:restapi_id/models/:model_name/default_template"]
                                                       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}}/restapis/:restapi_id/models/:model_name/default_template" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template",
  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}}/restapis/:restapi_id/models/:model_name/default_template');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/models/:model_name/default_template")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template")

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/restapis/:restapi_id/models/:model_name/default_template') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template";

    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}}/restapis/:restapi_id/models/:model_name/default_template

http GET {{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/models/:model_name/default_template")! 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 GetModels

{{baseUrl}}/restapis/:restapi_id/models

QUERY PARAMS

restapi_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/models");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/models")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/models"

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}}/restapis/:restapi_id/models"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/models");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/models"

	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/restapis/:restapi_id/models HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/models")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/models"))
    .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}}/restapis/:restapi_id/models")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/models")
  .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}}/restapis/:restapi_id/models');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/restapis/:restapi_id/models'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/models';
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}}/restapis/:restapi_id/models',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/models")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/models',
  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}}/restapis/:restapi_id/models'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/models');

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}}/restapis/:restapi_id/models'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/models';
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}}/restapis/:restapi_id/models"]
                                                       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}}/restapis/:restapi_id/models" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/models",
  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}}/restapis/:restapi_id/models');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/models');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/models');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/models' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/models' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/models")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/models"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/models"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/models")

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/restapis/:restapi_id/models') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/models";

    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}}/restapis/:restapi_id/models

http GET {{baseUrl}}/restapis/:restapi_id/models

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/models

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/models")! 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 GetRequestValidator

{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id

QUERY PARAMS

restapi_id

requestvalidator_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/restapis/:restapi_id/requestvalidators/:requestvalidator_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/requestvalidators/:requestvalidator_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/requestvalidators/:requestvalidator_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restapis/:restapi_id/requestvalidators/:requestvalidator_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id

http GET {{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetRequestValidators

{{baseUrl}}/restapis/:restapi_id/requestvalidators

QUERY PARAMS

restapi_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/requestvalidators");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/requestvalidators")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators"

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}}/restapis/:restapi_id/requestvalidators"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/requestvalidators");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/requestvalidators"

	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/restapis/:restapi_id/requestvalidators HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/requestvalidators")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/requestvalidators"))
    .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}}/restapis/:restapi_id/requestvalidators")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/requestvalidators")
  .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}}/restapis/:restapi_id/requestvalidators');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/requestvalidators';
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}}/restapis/:restapi_id/requestvalidators',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/requestvalidators")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/requestvalidators',
  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}}/restapis/:restapi_id/requestvalidators'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/requestvalidators');

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}}/restapis/:restapi_id/requestvalidators'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/requestvalidators';
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}}/restapis/:restapi_id/requestvalidators"]
                                                       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}}/restapis/:restapi_id/requestvalidators" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/requestvalidators",
  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}}/restapis/:restapi_id/requestvalidators');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/requestvalidators');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/requestvalidators');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/requestvalidators' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/requestvalidators' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/requestvalidators")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/requestvalidators"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/requestvalidators")

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/restapis/:restapi_id/requestvalidators') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators";

    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}}/restapis/:restapi_id/requestvalidators

http GET {{baseUrl}}/restapis/:restapi_id/requestvalidators

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/requestvalidators

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/requestvalidators")! 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 GetResource

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id

QUERY PARAMS

restapi_id

resource_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/restapis/:restapi_id/resources/:resource_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources/:resource_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/resources/:resource_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restapis/:restapi_id/resources/:resource_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/restapis/:restapi_id/resources/:resource_id

http GET {{baseUrl}}/restapis/:restapi_id/resources/:resource_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetResources

{{baseUrl}}/restapis/:restapi_id/resources

QUERY PARAMS

restapi_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/resources")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources"

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}}/restapis/:restapi_id/resources"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources"

	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/restapis/:restapi_id/resources HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/resources")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources"))
    .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}}/restapis/:restapi_id/resources")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/resources")
  .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}}/restapis/:restapi_id/resources');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/resources'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources';
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}}/restapis/:restapi_id/resources',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources',
  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}}/restapis/:restapi_id/resources'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/resources');

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}}/restapis/:restapi_id/resources'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources';
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}}/restapis/:restapi_id/resources"]
                                                       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}}/restapis/:restapi_id/resources" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources",
  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}}/restapis/:restapi_id/resources');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/resources")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources")

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/restapis/:restapi_id/resources') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources";

    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}}/restapis/:restapi_id/resources

http GET {{baseUrl}}/restapis/:restapi_id/resources

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources")! 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 GetRestApi

{{baseUrl}}/restapis/:restapi_id

QUERY PARAMS

restapi_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/restapis/:restapi_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restapis/:restapi_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/restapis/:restapi_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/restapis/:restapi_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/restapis/:restapi_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restapis/:restapi_id');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restapis/:restapi_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/restapis/:restapi_id

http GET {{baseUrl}}/restapis/:restapi_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetRestApis

{{baseUrl}}/restapis

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis")

require "http/client"

url = "{{baseUrl}}/restapis"

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}}/restapis"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis"

	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/restapis HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis"))
    .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}}/restapis")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis")
  .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}}/restapis');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/restapis'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis';
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}}/restapis',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis',
  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}}/restapis'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis');

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}}/restapis'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis';
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}}/restapis"]
                                                       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}}/restapis" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis",
  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}}/restapis');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis")

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/restapis') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis";

    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}}/restapis

http GET {{baseUrl}}/restapis

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis")! 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 GetSdk

{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type

QUERY PARAMS

restapi_id

stage_name

sdk_type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type"

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}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type"

	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/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type"))
    .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}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type")
  .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}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type';
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}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type',
  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}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type';
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}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type"]
                                                       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}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type",
  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}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type")

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/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type";

    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}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type

http GET {{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name/sdks/:sdk_type")! 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 GetSdkType

{{baseUrl}}/sdktypes/:sdktype_id

QUERY PARAMS

sdktype_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/sdktypes/:sdktype_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/sdktypes/:sdktype_id")

require "http/client"

url = "{{baseUrl}}/sdktypes/:sdktype_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/sdktypes/:sdktype_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/sdktypes/:sdktype_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/sdktypes/:sdktype_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/sdktypes/:sdktype_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/sdktypes/:sdktype_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sdktypes/:sdktype_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/sdktypes/:sdktype_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/sdktypes/:sdktype_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/sdktypes/:sdktype_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/sdktypes/:sdktype_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/sdktypes/:sdktype_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/sdktypes/:sdktype_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/sdktypes/:sdktype_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/sdktypes/:sdktype_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/sdktypes/:sdktype_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/sdktypes/:sdktype_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/sdktypes/:sdktype_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/sdktypes/:sdktype_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/sdktypes/:sdktype_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/sdktypes/:sdktype_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/sdktypes/:sdktype_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/sdktypes/:sdktype_id');

echo $response->getBody();

setUrl('{{baseUrl}}/sdktypes/:sdktype_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/sdktypes/:sdktype_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/sdktypes/:sdktype_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/sdktypes/:sdktype_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/sdktypes/:sdktype_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/sdktypes/:sdktype_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/sdktypes/:sdktype_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/sdktypes/:sdktype_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/sdktypes/:sdktype_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/sdktypes/:sdktype_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/sdktypes/:sdktype_id

http GET {{baseUrl}}/sdktypes/:sdktype_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/sdktypes/:sdktype_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sdktypes/:sdktype_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetSdkTypes

{{baseUrl}}/sdktypes

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/sdktypes");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/sdktypes")

require "http/client"

url = "{{baseUrl}}/sdktypes"

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}}/sdktypes"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/sdktypes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/sdktypes"

	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/sdktypes HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/sdktypes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sdktypes"))
    .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}}/sdktypes")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/sdktypes")
  .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}}/sdktypes');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/sdktypes'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/sdktypes';
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}}/sdktypes',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/sdktypes")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/sdktypes',
  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}}/sdktypes'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/sdktypes');

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}}/sdktypes'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/sdktypes';
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}}/sdktypes"]
                                                       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}}/sdktypes" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/sdktypes",
  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}}/sdktypes');

echo $response->getBody();

setUrl('{{baseUrl}}/sdktypes');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/sdktypes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/sdktypes' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/sdktypes' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/sdktypes")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/sdktypes"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/sdktypes"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/sdktypes")

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/sdktypes') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/sdktypes";

    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}}/sdktypes

http GET {{baseUrl}}/sdktypes

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/sdktypes

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sdktypes")! 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 GetStage

{{baseUrl}}/restapis/:restapi_id/stages/:stage_name

QUERY PARAMS

restapi_id

stage_name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/restapis/:restapi_id/stages/:stage_name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/stages/:stage_name',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/stages/:stage_name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/restapis/:restapi_id/stages/:stage_name') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/restapis/:restapi_id/stages/:stage_name

http GET {{baseUrl}}/restapis/:restapi_id/stages/:stage_name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/stages/:stage_name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetStages

{{baseUrl}}/restapis/:restapi_id/stages

QUERY PARAMS

restapi_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/stages");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restapis/:restapi_id/stages")

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/stages"

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}}/restapis/:restapi_id/stages"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/stages");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/stages"

	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/restapis/:restapi_id/stages HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restapis/:restapi_id/stages")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/stages"))
    .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}}/restapis/:restapi_id/stages")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restapis/:restapi_id/stages")
  .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}}/restapis/:restapi_id/stages');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/restapis/:restapi_id/stages'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/stages';
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}}/restapis/:restapi_id/stages',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/stages',
  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}}/restapis/:restapi_id/stages'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restapis/:restapi_id/stages');

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}}/restapis/:restapi_id/stages'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/stages';
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}}/restapis/:restapi_id/stages"]
                                                       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}}/restapis/:restapi_id/stages" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/stages",
  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}}/restapis/:restapi_id/stages');

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/stages');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restapis/:restapi_id/stages');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/stages' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/stages' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restapis/:restapi_id/stages")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/stages"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/stages"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/stages")

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/restapis/:restapi_id/stages') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/stages";

    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}}/restapis/:restapi_id/stages

http GET {{baseUrl}}/restapis/:restapi_id/stages

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/stages

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/stages")! 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 GetTags

{{baseUrl}}/tags/:resource_arn

QUERY PARAMS

resource_arn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resource_arn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tags/:resource_arn")

require "http/client"

url = "{{baseUrl}}/tags/:resource_arn"

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}}/tags/:resource_arn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resource_arn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resource_arn"

	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/tags/:resource_arn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tags/:resource_arn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resource_arn"))
    .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}}/tags/:resource_arn")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tags/:resource_arn")
  .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}}/tags/:resource_arn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resource_arn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resource_arn';
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}}/tags/:resource_arn',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resource_arn")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resource_arn',
  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}}/tags/:resource_arn'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tags/:resource_arn');

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}}/tags/:resource_arn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resource_arn';
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}}/tags/:resource_arn"]
                                                       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}}/tags/:resource_arn" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resource_arn",
  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}}/tags/:resource_arn');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resource_arn');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags/:resource_arn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resource_arn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resource_arn' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/tags/:resource_arn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resource_arn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resource_arn"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resource_arn")

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/tags/:resource_arn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resource_arn";

    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}}/tags/:resource_arn

http GET {{baseUrl}}/tags/:resource_arn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/tags/:resource_arn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resource_arn")! 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 GetUsage

{{baseUrl}}/usageplans/:usageplanId/usage#startDate&endDate

QUERY PARAMS

startDate

endDate

usageplanId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/usageplans/:usageplanId/usage#startDate&endDate" {:query-params {:startDate ""
                                                                                                          :endDate ""}})

require "http/client"

url = "{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate"

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}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate"

	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/usageplans/:usageplanId/usage?startDate=&endDate= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate"))
    .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}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate")
  .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}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/usageplans/:usageplanId/usage#startDate&endDate',
  params: {startDate: '', endDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate';
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}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/usageplans/:usageplanId/usage?startDate=&endDate=',
  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}}/usageplans/:usageplanId/usage#startDate&endDate',
  qs: {startDate: '', endDate: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/usageplans/:usageplanId/usage#startDate&endDate');

req.query({
  startDate: '',
  endDate: ''
});

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}}/usageplans/:usageplanId/usage#startDate&endDate',
  params: {startDate: '', endDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate';
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}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate"]
                                                       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}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate",
  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}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate');

echo $response->getBody();

setUrl('{{baseUrl}}/usageplans/:usageplanId/usage#startDate&endDate');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'startDate' => '',
  'endDate' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/usageplans/:usageplanId/usage#startDate&endDate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'startDate' => '',
  'endDate' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/usageplans/:usageplanId/usage?startDate=&endDate=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/usageplans/:usageplanId/usage#startDate&endDate"

querystring = {"startDate":"","endDate":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/usageplans/:usageplanId/usage#startDate&endDate"

queryString <- list(
  startDate = "",
  endDate = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate")

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/usageplans/:usageplanId/usage') do |req|
  req.params['startDate'] = ''
  req.params['endDate'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/usageplans/:usageplanId/usage#startDate&endDate";

    let querystring = [
        ("startDate", ""),
        ("endDate", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate'

http GET '{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usageplans/:usageplanId/usage?startDate=&endDate=#startDate&endDate")! 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 GetUsagePlan

{{baseUrl}}/usageplans/:usageplanId

QUERY PARAMS

usageplanId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usageplans/:usageplanId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/usageplans/:usageplanId")

require "http/client"

url = "{{baseUrl}}/usageplans/:usageplanId"

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}}/usageplans/:usageplanId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/usageplans/:usageplanId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/usageplans/:usageplanId"

	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/usageplans/:usageplanId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/usageplans/:usageplanId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/usageplans/:usageplanId"))
    .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}}/usageplans/:usageplanId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/usageplans/:usageplanId")
  .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}}/usageplans/:usageplanId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/usageplans/:usageplanId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/usageplans/:usageplanId';
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}}/usageplans/:usageplanId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/usageplans/:usageplanId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/usageplans/:usageplanId',
  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}}/usageplans/:usageplanId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/usageplans/:usageplanId');

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}}/usageplans/:usageplanId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/usageplans/:usageplanId';
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}}/usageplans/:usageplanId"]
                                                       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}}/usageplans/:usageplanId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/usageplans/:usageplanId",
  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}}/usageplans/:usageplanId');

echo $response->getBody();

setUrl('{{baseUrl}}/usageplans/:usageplanId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/usageplans/:usageplanId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/usageplans/:usageplanId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/usageplans/:usageplanId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/usageplans/:usageplanId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/usageplans/:usageplanId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/usageplans/:usageplanId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/usageplans/:usageplanId")

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/usageplans/:usageplanId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/usageplans/:usageplanId";

    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}}/usageplans/:usageplanId

http GET {{baseUrl}}/usageplans/:usageplanId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/usageplans/:usageplanId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usageplans/:usageplanId")! 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 GetUsagePlanKey

{{baseUrl}}/usageplans/:usageplanId/keys/:keyId

QUERY PARAMS

usageplanId

keyId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")

require "http/client"

url = "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId"

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}}/usageplans/:usageplanId/keys/:keyId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId"

	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/usageplans/:usageplanId/keys/:keyId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId"))
    .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}}/usageplans/:usageplanId/keys/:keyId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")
  .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}}/usageplans/:usageplanId/keys/:keyId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId';
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}}/usageplans/:usageplanId/keys/:keyId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/usageplans/:usageplanId/keys/:keyId',
  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}}/usageplans/:usageplanId/keys/:keyId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId');

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}}/usageplans/:usageplanId/keys/:keyId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId';
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}}/usageplans/:usageplanId/keys/:keyId"]
                                                       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}}/usageplans/:usageplanId/keys/:keyId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId",
  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}}/usageplans/:usageplanId/keys/:keyId');

echo $response->getBody();

setUrl('{{baseUrl}}/usageplans/:usageplanId/keys/:keyId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/usageplans/:usageplanId/keys/:keyId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/usageplans/:usageplanId/keys/:keyId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")

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/usageplans/:usageplanId/keys/:keyId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId";

    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}}/usageplans/:usageplanId/keys/:keyId

http GET {{baseUrl}}/usageplans/:usageplanId/keys/:keyId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/usageplans/:usageplanId/keys/:keyId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId")! 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 GetUsagePlanKeys

{{baseUrl}}/usageplans/:usageplanId/keys

QUERY PARAMS

usageplanId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usageplans/:usageplanId/keys");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/usageplans/:usageplanId/keys")

require "http/client"

url = "{{baseUrl}}/usageplans/:usageplanId/keys"

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}}/usageplans/:usageplanId/keys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/usageplans/:usageplanId/keys");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/usageplans/:usageplanId/keys"

	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/usageplans/:usageplanId/keys HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/usageplans/:usageplanId/keys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/usageplans/:usageplanId/keys"))
    .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}}/usageplans/:usageplanId/keys")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/usageplans/:usageplanId/keys")
  .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}}/usageplans/:usageplanId/keys');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/usageplans/:usageplanId/keys'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/usageplans/:usageplanId/keys';
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}}/usageplans/:usageplanId/keys',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/usageplans/:usageplanId/keys")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/usageplans/:usageplanId/keys',
  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}}/usageplans/:usageplanId/keys'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/usageplans/:usageplanId/keys');

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}}/usageplans/:usageplanId/keys'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/usageplans/:usageplanId/keys';
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}}/usageplans/:usageplanId/keys"]
                                                       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}}/usageplans/:usageplanId/keys" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/usageplans/:usageplanId/keys",
  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}}/usageplans/:usageplanId/keys');

echo $response->getBody();

setUrl('{{baseUrl}}/usageplans/:usageplanId/keys');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/usageplans/:usageplanId/keys');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/usageplans/:usageplanId/keys' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/usageplans/:usageplanId/keys' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/usageplans/:usageplanId/keys")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/usageplans/:usageplanId/keys"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/usageplans/:usageplanId/keys"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/usageplans/:usageplanId/keys")

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/usageplans/:usageplanId/keys') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/usageplans/:usageplanId/keys";

    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}}/usageplans/:usageplanId/keys

http GET {{baseUrl}}/usageplans/:usageplanId/keys

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/usageplans/:usageplanId/keys

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usageplans/:usageplanId/keys")! 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 GetUsagePlans

{{baseUrl}}/usageplans

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usageplans");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/usageplans")

require "http/client"

url = "{{baseUrl}}/usageplans"

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}}/usageplans"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/usageplans");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/usageplans"

	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/usageplans HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/usageplans")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/usageplans"))
    .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}}/usageplans")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/usageplans")
  .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}}/usageplans');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/usageplans'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/usageplans';
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}}/usageplans',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/usageplans")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/usageplans',
  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}}/usageplans'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/usageplans');

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}}/usageplans'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/usageplans';
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}}/usageplans"]
                                                       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}}/usageplans" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/usageplans",
  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}}/usageplans');

echo $response->getBody();

setUrl('{{baseUrl}}/usageplans');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/usageplans');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/usageplans' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/usageplans' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/usageplans")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/usageplans"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/usageplans"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/usageplans")

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/usageplans') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/usageplans";

    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}}/usageplans

http GET {{baseUrl}}/usageplans

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/usageplans

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usageplans")! 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 GetVpcLink

{{baseUrl}}/vpclinks/:vpclink_id

QUERY PARAMS

vpclink_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vpclinks/:vpclink_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vpclinks/:vpclink_id")

require "http/client"

url = "{{baseUrl}}/vpclinks/:vpclink_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/vpclinks/:vpclink_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/vpclinks/:vpclink_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vpclinks/:vpclink_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/vpclinks/:vpclink_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vpclinks/:vpclink_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vpclinks/:vpclink_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vpclinks/:vpclink_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/vpclinks/:vpclink_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/vpclinks/:vpclink_id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vpclinks/:vpclink_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/vpclinks/:vpclink_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vpclinks/:vpclink_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vpclinks/:vpclink_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vpclinks/:vpclink_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/vpclinks/:vpclink_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vpclinks/:vpclink_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/vpclinks/:vpclink_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/vpclinks/:vpclink_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vpclinks/:vpclink_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vpclinks/:vpclink_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/vpclinks/:vpclink_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/vpclinks/:vpclink_id');

echo $response->getBody();

setUrl('{{baseUrl}}/vpclinks/:vpclink_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/vpclinks/:vpclink_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/vpclinks/:vpclink_id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/vpclinks/:vpclink_id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/vpclinks/:vpclink_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/vpclinks/:vpclink_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/vpclinks/:vpclink_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vpclinks/:vpclink_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/vpclinks/:vpclink_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vpclinks/:vpclink_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/vpclinks/:vpclink_id

http GET {{baseUrl}}/vpclinks/:vpclink_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vpclinks/:vpclink_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vpclinks/:vpclink_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetVpcLinks

{{baseUrl}}/vpclinks

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vpclinks");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vpclinks")

require "http/client"

url = "{{baseUrl}}/vpclinks"

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}}/vpclinks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/vpclinks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vpclinks"

	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/vpclinks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vpclinks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vpclinks"))
    .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}}/vpclinks")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/vpclinks")
  .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}}/vpclinks');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vpclinks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/vpclinks';
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}}/vpclinks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vpclinks")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vpclinks',
  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}}/vpclinks'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vpclinks');

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}}/vpclinks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/vpclinks';
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}}/vpclinks"]
                                                       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}}/vpclinks" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/vpclinks",
  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}}/vpclinks');

echo $response->getBody();

setUrl('{{baseUrl}}/vpclinks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/vpclinks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/vpclinks' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/vpclinks' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/vpclinks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/vpclinks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/vpclinks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vpclinks")

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/vpclinks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vpclinks";

    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}}/vpclinks

http GET {{baseUrl}}/vpclinks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vpclinks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vpclinks")! 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 ImportApiKeys

{{baseUrl}}/apikeys#mode=import&format

QUERY PARAMS

format

mode

BODY json

{
  "body": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/apikeys?format=&mode=#mode=import&format");

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  \"body\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/apikeys#mode=import&format" {:query-params {:format ""
                                                                                      :mode ""}
                                                                       :content-type :json
                                                                       :form-params {:body ""}})

require "http/client"

url = "{{baseUrl}}/apikeys?format=&mode=#mode=import&format"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"body\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/apikeys?format=&mode=#mode=import&format"),
    Content = new StringContent("{\n  \"body\": \"\"\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}}/apikeys?format=&mode=#mode=import&format");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"body\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/apikeys?format=&mode=#mode=import&format"

	payload := strings.NewReader("{\n  \"body\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/apikeys?format=&mode= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "body": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/apikeys?format=&mode=#mode=import&format")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"body\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/apikeys?format=&mode=#mode=import&format"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"body\": \"\"\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  \"body\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/apikeys?format=&mode=#mode=import&format")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/apikeys?format=&mode=#mode=import&format")
  .header("content-type", "application/json")
  .body("{\n  \"body\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  body: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/apikeys?format=&mode=#mode=import&format');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/apikeys#mode=import&format',
  params: {format: '', mode: ''},
  headers: {'content-type': 'application/json'},
  data: {body: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/apikeys?format=&mode=#mode=import&format';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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}}/apikeys?format=&mode=#mode=import&format',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "body": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"body\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/apikeys?format=&mode=#mode=import&format")
  .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/apikeys?format=&mode=',
  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({body: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/apikeys#mode=import&format',
  qs: {format: '', mode: ''},
  headers: {'content-type': 'application/json'},
  body: {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}}/apikeys#mode=import&format');

req.query({
  format: '',
  mode: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  body: ''
});

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}}/apikeys#mode=import&format',
  params: {format: '', mode: ''},
  headers: {'content-type': 'application/json'},
  data: {body: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/apikeys?format=&mode=#mode=import&format';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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 = @{ @"body": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/apikeys?format=&mode=#mode=import&format"]
                                                       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}}/apikeys?format=&mode=#mode=import&format" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"body\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/apikeys?format=&mode=#mode=import&format",
  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([
    'body' => ''
  ]),
  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}}/apikeys?format=&mode=#mode=import&format', [
  'body' => '{
  "body": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/apikeys#mode=import&format');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'format' => '',
  'mode' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'body' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'body' => ''
]));
$request->setRequestUrl('{{baseUrl}}/apikeys#mode=import&format');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'format' => '',
  'mode' => ''
]));

$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}}/apikeys?format=&mode=#mode=import&format' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "body": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/apikeys?format=&mode=#mode=import&format' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "body": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"body\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/apikeys?format=&mode=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/apikeys#mode=import&format"

querystring = {"format":"","mode":""}

payload = { "body": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/apikeys#mode=import&format"

queryString <- list(
  format = "",
  mode = ""
)

payload <- "{\n  \"body\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/apikeys?format=&mode=#mode=import&format")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"body\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/apikeys') do |req|
  req.params['format'] = ''
  req.params['mode'] = ''
  req.body = "{\n  \"body\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/apikeys#mode=import&format";

    let querystring = [
        ("format", ""),
        ("mode", ""),
    ];

    let payload = json!({"body": ""});

    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)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/apikeys?format=&mode=#mode=import&format' \
  --header 'content-type: application/json' \
  --data '{
  "body": ""
}'

echo '{
  "body": ""
}' |  \
  http POST '{{baseUrl}}/apikeys?format=&mode=#mode=import&format' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "body": ""\n}' \
  --output-document \
  - '{{baseUrl}}/apikeys?format=&mode=#mode=import&format'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["body": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/apikeys?format=&mode=#mode=import&format")! 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()

PUT ImportDocumentationParts

{{baseUrl}}/restapis/:restapi_id/documentation/parts

QUERY PARAMS

restapi_id

BODY json

{
  "body": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/documentation/parts");

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  \"body\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restapis/:restapi_id/documentation/parts" {:content-type :json
                                                                                    :form-params {:body ""}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"body\": \"\"\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}}/restapis/:restapi_id/documentation/parts"),
    Content = new StringContent("{\n  \"body\": \"\"\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}}/restapis/:restapi_id/documentation/parts");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"body\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/documentation/parts"

	payload := strings.NewReader("{\n  \"body\": \"\"\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/restapis/:restapi_id/documentation/parts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "body": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restapis/:restapi_id/documentation/parts")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"body\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/documentation/parts"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"body\": \"\"\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  \"body\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/parts")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restapis/:restapi_id/documentation/parts")
  .header("content-type", "application/json")
  .body("{\n  \"body\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  body: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restapis/:restapi_id/documentation/parts');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts',
  headers: {'content-type': 'application/json'},
  data: {body: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"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}}/restapis/:restapi_id/documentation/parts',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "body": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"body\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/parts")
  .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/restapis/:restapi_id/documentation/parts',
  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({body: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts',
  headers: {'content-type': 'application/json'},
  body: {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}}/restapis/:restapi_id/documentation/parts');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  body: ''
});

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}}/restapis/:restapi_id/documentation/parts',
  headers: {'content-type': 'application/json'},
  data: {body: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"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 = @{ @"body": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/documentation/parts"]
                                                       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}}/restapis/:restapi_id/documentation/parts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"body\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/documentation/parts",
  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([
    'body' => ''
  ]),
  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}}/restapis/:restapi_id/documentation/parts', [
  'body' => '{
  "body": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'body' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'body' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts');
$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}}/restapis/:restapi_id/documentation/parts' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "body": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/parts' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "body": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"body\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restapis/:restapi_id/documentation/parts", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts"

payload = { "body": "" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/documentation/parts"

payload <- "{\n  \"body\": \"\"\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}}/restapis/:restapi_id/documentation/parts")

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  \"body\": \"\"\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/restapis/:restapi_id/documentation/parts') do |req|
  req.body = "{\n  \"body\": \"\"\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}}/restapis/:restapi_id/documentation/parts";

    let payload = json!({"body": ""});

    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}}/restapis/:restapi_id/documentation/parts \
  --header 'content-type: application/json' \
  --data '{
  "body": ""
}'

echo '{
  "body": ""
}' |  \
  http PUT {{baseUrl}}/restapis/:restapi_id/documentation/parts \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "body": ""\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/documentation/parts

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["body": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/documentation/parts")! 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()

POST ImportRestApi

{{baseUrl}}/restapis#mode=import

QUERY PARAMS

mode

BODY json

{
  "body": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis?mode=#mode=import");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"body\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restapis#mode=import" {:query-params {:mode ""}
                                                                 :content-type :json
                                                                 :form-params {:body ""}})

require "http/client"

url = "{{baseUrl}}/restapis?mode=#mode=import"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"body\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis?mode=#mode=import"),
    Content = new StringContent("{\n  \"body\": \"\"\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}}/restapis?mode=#mode=import");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"body\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis?mode=#mode=import"

	payload := strings.NewReader("{\n  \"body\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/restapis?mode= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "body": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis?mode=#mode=import")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"body\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis?mode=#mode=import"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"body\": \"\"\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  \"body\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis?mode=#mode=import")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restapis?mode=#mode=import")
  .header("content-type", "application/json")
  .body("{\n  \"body\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  body: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restapis?mode=#mode=import');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis#mode=import',
  params: {mode: ''},
  headers: {'content-type': 'application/json'},
  data: {body: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis?mode=#mode=import';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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}}/restapis?mode=#mode=import',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "body": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"body\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis?mode=#mode=import")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis?mode=',
  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({body: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis#mode=import',
  qs: {mode: ''},
  headers: {'content-type': 'application/json'},
  body: {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}}/restapis#mode=import');

req.query({
  mode: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  body: ''
});

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}}/restapis#mode=import',
  params: {mode: ''},
  headers: {'content-type': 'application/json'},
  data: {body: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis?mode=#mode=import';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"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 = @{ @"body": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis?mode=#mode=import"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis?mode=#mode=import" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"body\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis?mode=#mode=import",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'body' => ''
  ]),
  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}}/restapis?mode=#mode=import', [
  'body' => '{
  "body": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis#mode=import');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'mode' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'body' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'body' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restapis#mode=import');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'mode' => ''
]));

$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}}/restapis?mode=#mode=import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "body": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis?mode=#mode=import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "body": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"body\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restapis?mode=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis#mode=import"

querystring = {"mode":""}

payload = { "body": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis#mode=import"

queryString <- list(mode = "")

payload <- "{\n  \"body\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis?mode=#mode=import")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"body\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restapis') do |req|
  req.params['mode'] = ''
  req.body = "{\n  \"body\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis#mode=import";

    let querystring = [
        ("mode", ""),
    ];

    let payload = json!({"body": ""});

    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)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/restapis?mode=#mode=import' \
  --header 'content-type: application/json' \
  --data '{
  "body": ""
}'

echo '{
  "body": ""
}' |  \
  http POST '{{baseUrl}}/restapis?mode=#mode=import' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "body": ""\n}' \
  --output-document \
  - '{{baseUrl}}/restapis?mode=#mode=import'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["body": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis?mode=#mode=import")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT PutGatewayResponse

{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type

QUERY PARAMS

restapi_id

response_type

BODY json

{
  "statusCode": "",
  "responseParameters": {},
  "responseTemplates": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type");

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  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type" {:content-type :json
                                                                                                :form-params {:statusCode ""
                                                                                                              :responseParameters {}
                                                                                                              :responseTemplates {}}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\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}}/restapis/:restapi_id/gatewayresponses/:response_type"),
    Content = new StringContent("{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\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}}/restapis/:restapi_id/gatewayresponses/:response_type");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

	payload := strings.NewReader("{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\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/restapis/:restapi_id/gatewayresponses/:response_type HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 77

{
  "statusCode": "",
  "responseParameters": {},
  "responseTemplates": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\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  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .header("content-type", "application/json")
  .body("{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\n}")
  .asString();

const data = JSON.stringify({
  statusCode: '',
  responseParameters: {},
  responseTemplates: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type',
  headers: {'content-type': 'application/json'},
  data: {statusCode: '', responseParameters: {}, responseTemplates: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"statusCode":"","responseParameters":{},"responseTemplates":{}}'
};

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}}/restapis/:restapi_id/gatewayresponses/:response_type',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "statusCode": "",\n  "responseParameters": {},\n  "responseTemplates": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .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/restapis/:restapi_id/gatewayresponses/:response_type',
  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({statusCode: '', responseParameters: {}, responseTemplates: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type',
  headers: {'content-type': 'application/json'},
  body: {statusCode: '', responseParameters: {}, responseTemplates: {}},
  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}}/restapis/:restapi_id/gatewayresponses/:response_type');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  statusCode: '',
  responseParameters: {},
  responseTemplates: {}
});

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}}/restapis/:restapi_id/gatewayresponses/:response_type',
  headers: {'content-type': 'application/json'},
  data: {statusCode: '', responseParameters: {}, responseTemplates: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"statusCode":"","responseParameters":{},"responseTemplates":{}}'
};

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 = @{ @"statusCode": @"",
                              @"responseParameters": @{  },
                              @"responseTemplates": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"]
                                                       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}}/restapis/:restapi_id/gatewayresponses/:response_type" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type",
  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([
    'statusCode' => '',
    'responseParameters' => [
        
    ],
    'responseTemplates' => [
        
    ]
  ]),
  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}}/restapis/:restapi_id/gatewayresponses/:response_type', [
  'body' => '{
  "statusCode": "",
  "responseParameters": {},
  "responseTemplates": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'statusCode' => '',
  'responseParameters' => [
    
  ],
  'responseTemplates' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'statusCode' => '',
  'responseParameters' => [
    
  ],
  'responseTemplates' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');
$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}}/restapis/:restapi_id/gatewayresponses/:response_type' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "statusCode": "",
  "responseParameters": {},
  "responseTemplates": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "statusCode": "",
  "responseParameters": {},
  "responseTemplates": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restapis/:restapi_id/gatewayresponses/:response_type", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

payload = {
    "statusCode": "",
    "responseParameters": {},
    "responseTemplates": {}
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

payload <- "{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\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}}/restapis/:restapi_id/gatewayresponses/:response_type")

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  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\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/restapis/:restapi_id/gatewayresponses/:response_type') do |req|
  req.body = "{\n  \"statusCode\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {}\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}}/restapis/:restapi_id/gatewayresponses/:response_type";

    let payload = json!({
        "statusCode": "",
        "responseParameters": json!({}),
        "responseTemplates": 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}}/restapis/:restapi_id/gatewayresponses/:response_type \
  --header 'content-type: application/json' \
  --data '{
  "statusCode": "",
  "responseParameters": {},
  "responseTemplates": {}
}'

echo '{
  "statusCode": "",
  "responseParameters": {},
  "responseTemplates": {}
}' |  \
  http PUT {{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "statusCode": "",\n  "responseParameters": {},\n  "responseTemplates": {}\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "statusCode": "",
  "responseParameters": [],
  "responseTemplates": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")! 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()

PUT PutIntegration

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

QUERY PARAMS

restapi_id

resource_id

http_method

BODY json

{
  "type": "",
  "httpMethod": "",
  "uri": "",
  "connectionType": "",
  "connectionId": "",
  "credentials": "",
  "requestParameters": {},
  "requestTemplates": {},
  "passthroughBehavior": "",
  "cacheNamespace": "",
  "cacheKeyParameters": [],
  "contentHandling": "",
  "timeoutInMillis": 0,
  "tlsConfig": {
    "insecureSkipVerification": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration");

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  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration" {:content-type :json
                                                                                                                        :form-params {:type ""
                                                                                                                                      :httpMethod ""
                                                                                                                                      :uri ""
                                                                                                                                      :connectionType ""
                                                                                                                                      :connectionId ""
                                                                                                                                      :credentials ""
                                                                                                                                      :requestParameters {}
                                                                                                                                      :requestTemplates {}
                                                                                                                                      :passthroughBehavior ""
                                                                                                                                      :cacheNamespace ""
                                                                                                                                      :cacheKeyParameters []
                                                                                                                                      :contentHandling ""
                                                                                                                                      :timeoutInMillis 0
                                                                                                                                      :tlsConfig {:insecureSkipVerification ""}}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"),
    Content = new StringContent("{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

	payload := strings.NewReader("{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 356

{
  "type": "",
  "httpMethod": "",
  "uri": "",
  "connectionType": "",
  "connectionId": "",
  "credentials": "",
  "requestParameters": {},
  "requestTemplates": {},
  "passthroughBehavior": "",
  "cacheNamespace": "",
  "cacheKeyParameters": [],
  "contentHandling": "",
  "timeoutInMillis": 0,
  "tlsConfig": {
    "insecureSkipVerification": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .header("content-type", "application/json")
  .body("{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  type: '',
  httpMethod: '',
  uri: '',
  connectionType: '',
  connectionId: '',
  credentials: '',
  requestParameters: {},
  requestTemplates: {},
  passthroughBehavior: '',
  cacheNamespace: '',
  cacheKeyParameters: [],
  contentHandling: '',
  timeoutInMillis: 0,
  tlsConfig: {
    insecureSkipVerification: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  headers: {'content-type': 'application/json'},
  data: {
    type: '',
    httpMethod: '',
    uri: '',
    connectionType: '',
    connectionId: '',
    credentials: '',
    requestParameters: {},
    requestTemplates: {},
    passthroughBehavior: '',
    cacheNamespace: '',
    cacheKeyParameters: [],
    contentHandling: '',
    timeoutInMillis: 0,
    tlsConfig: {insecureSkipVerification: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"type":"","httpMethod":"","uri":"","connectionType":"","connectionId":"","credentials":"","requestParameters":{},"requestTemplates":{},"passthroughBehavior":"","cacheNamespace":"","cacheKeyParameters":[],"contentHandling":"","timeoutInMillis":0,"tlsConfig":{"insecureSkipVerification":""}}'
};

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "type": "",\n  "httpMethod": "",\n  "uri": "",\n  "connectionType": "",\n  "connectionId": "",\n  "credentials": "",\n  "requestParameters": {},\n  "requestTemplates": {},\n  "passthroughBehavior": "",\n  "cacheNamespace": "",\n  "cacheKeyParameters": [],\n  "contentHandling": "",\n  "timeoutInMillis": 0,\n  "tlsConfig": {\n    "insecureSkipVerification": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  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({
  type: '',
  httpMethod: '',
  uri: '',
  connectionType: '',
  connectionId: '',
  credentials: '',
  requestParameters: {},
  requestTemplates: {},
  passthroughBehavior: '',
  cacheNamespace: '',
  cacheKeyParameters: [],
  contentHandling: '',
  timeoutInMillis: 0,
  tlsConfig: {insecureSkipVerification: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  headers: {'content-type': 'application/json'},
  body: {
    type: '',
    httpMethod: '',
    uri: '',
    connectionType: '',
    connectionId: '',
    credentials: '',
    requestParameters: {},
    requestTemplates: {},
    passthroughBehavior: '',
    cacheNamespace: '',
    cacheKeyParameters: [],
    contentHandling: '',
    timeoutInMillis: 0,
    tlsConfig: {insecureSkipVerification: ''}
  },
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  type: '',
  httpMethod: '',
  uri: '',
  connectionType: '',
  connectionId: '',
  credentials: '',
  requestParameters: {},
  requestTemplates: {},
  passthroughBehavior: '',
  cacheNamespace: '',
  cacheKeyParameters: [],
  contentHandling: '',
  timeoutInMillis: 0,
  tlsConfig: {
    insecureSkipVerification: ''
  }
});

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  headers: {'content-type': 'application/json'},
  data: {
    type: '',
    httpMethod: '',
    uri: '',
    connectionType: '',
    connectionId: '',
    credentials: '',
    requestParameters: {},
    requestTemplates: {},
    passthroughBehavior: '',
    cacheNamespace: '',
    cacheKeyParameters: [],
    contentHandling: '',
    timeoutInMillis: 0,
    tlsConfig: {insecureSkipVerification: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"type":"","httpMethod":"","uri":"","connectionType":"","connectionId":"","credentials":"","requestParameters":{},"requestTemplates":{},"passthroughBehavior":"","cacheNamespace":"","cacheKeyParameters":[],"contentHandling":"","timeoutInMillis":0,"tlsConfig":{"insecureSkipVerification":""}}'
};

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 = @{ @"type": @"",
                              @"httpMethod": @"",
                              @"uri": @"",
                              @"connectionType": @"",
                              @"connectionId": @"",
                              @"credentials": @"",
                              @"requestParameters": @{  },
                              @"requestTemplates": @{  },
                              @"passthroughBehavior": @"",
                              @"cacheNamespace": @"",
                              @"cacheKeyParameters": @[  ],
                              @"contentHandling": @"",
                              @"timeoutInMillis": @0,
                              @"tlsConfig": @{ @"insecureSkipVerification": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration",
  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([
    'type' => '',
    'httpMethod' => '',
    'uri' => '',
    'connectionType' => '',
    'connectionId' => '',
    'credentials' => '',
    'requestParameters' => [
        
    ],
    'requestTemplates' => [
        
    ],
    'passthroughBehavior' => '',
    'cacheNamespace' => '',
    'cacheKeyParameters' => [
        
    ],
    'contentHandling' => '',
    'timeoutInMillis' => 0,
    'tlsConfig' => [
        'insecureSkipVerification' => ''
    ]
  ]),
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration', [
  'body' => '{
  "type": "",
  "httpMethod": "",
  "uri": "",
  "connectionType": "",
  "connectionId": "",
  "credentials": "",
  "requestParameters": {},
  "requestTemplates": {},
  "passthroughBehavior": "",
  "cacheNamespace": "",
  "cacheKeyParameters": [],
  "contentHandling": "",
  "timeoutInMillis": 0,
  "tlsConfig": {
    "insecureSkipVerification": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'type' => '',
  'httpMethod' => '',
  'uri' => '',
  'connectionType' => '',
  'connectionId' => '',
  'credentials' => '',
  'requestParameters' => [
    
  ],
  'requestTemplates' => [
    
  ],
  'passthroughBehavior' => '',
  'cacheNamespace' => '',
  'cacheKeyParameters' => [
    
  ],
  'contentHandling' => '',
  'timeoutInMillis' => 0,
  'tlsConfig' => [
    'insecureSkipVerification' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'type' => '',
  'httpMethod' => '',
  'uri' => '',
  'connectionType' => '',
  'connectionId' => '',
  'credentials' => '',
  'requestParameters' => [
    
  ],
  'requestTemplates' => [
    
  ],
  'passthroughBehavior' => '',
  'cacheNamespace' => '',
  'cacheKeyParameters' => [
    
  ],
  'contentHandling' => '',
  'timeoutInMillis' => 0,
  'tlsConfig' => [
    'insecureSkipVerification' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');
$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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "type": "",
  "httpMethod": "",
  "uri": "",
  "connectionType": "",
  "connectionId": "",
  "credentials": "",
  "requestParameters": {},
  "requestTemplates": {},
  "passthroughBehavior": "",
  "cacheNamespace": "",
  "cacheKeyParameters": [],
  "contentHandling": "",
  "timeoutInMillis": 0,
  "tlsConfig": {
    "insecureSkipVerification": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "type": "",
  "httpMethod": "",
  "uri": "",
  "connectionType": "",
  "connectionId": "",
  "credentials": "",
  "requestParameters": {},
  "requestTemplates": {},
  "passthroughBehavior": "",
  "cacheNamespace": "",
  "cacheKeyParameters": [],
  "contentHandling": "",
  "timeoutInMillis": 0,
  "tlsConfig": {
    "insecureSkipVerification": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

payload = {
    "type": "",
    "httpMethod": "",
    "uri": "",
    "connectionType": "",
    "connectionId": "",
    "credentials": "",
    "requestParameters": {},
    "requestTemplates": {},
    "passthroughBehavior": "",
    "cacheNamespace": "",
    "cacheKeyParameters": [],
    "contentHandling": "",
    "timeoutInMillis": 0,
    "tlsConfig": { "insecureSkipVerification": "" }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

payload <- "{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")

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  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration') do |req|
  req.body = "{\n  \"type\": \"\",\n  \"httpMethod\": \"\",\n  \"uri\": \"\",\n  \"connectionType\": \"\",\n  \"connectionId\": \"\",\n  \"credentials\": \"\",\n  \"requestParameters\": {},\n  \"requestTemplates\": {},\n  \"passthroughBehavior\": \"\",\n  \"cacheNamespace\": \"\",\n  \"cacheKeyParameters\": [],\n  \"contentHandling\": \"\",\n  \"timeoutInMillis\": 0,\n  \"tlsConfig\": {\n    \"insecureSkipVerification\": \"\"\n  }\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration";

    let payload = json!({
        "type": "",
        "httpMethod": "",
        "uri": "",
        "connectionType": "",
        "connectionId": "",
        "credentials": "",
        "requestParameters": json!({}),
        "requestTemplates": json!({}),
        "passthroughBehavior": "",
        "cacheNamespace": "",
        "cacheKeyParameters": (),
        "contentHandling": "",
        "timeoutInMillis": 0,
        "tlsConfig": json!({"insecureSkipVerification": ""})
    });

    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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration \
  --header 'content-type: application/json' \
  --data '{
  "type": "",
  "httpMethod": "",
  "uri": "",
  "connectionType": "",
  "connectionId": "",
  "credentials": "",
  "requestParameters": {},
  "requestTemplates": {},
  "passthroughBehavior": "",
  "cacheNamespace": "",
  "cacheKeyParameters": [],
  "contentHandling": "",
  "timeoutInMillis": 0,
  "tlsConfig": {
    "insecureSkipVerification": ""
  }
}'

echo '{
  "type": "",
  "httpMethod": "",
  "uri": "",
  "connectionType": "",
  "connectionId": "",
  "credentials": "",
  "requestParameters": {},
  "requestTemplates": {},
  "passthroughBehavior": "",
  "cacheNamespace": "",
  "cacheKeyParameters": [],
  "contentHandling": "",
  "timeoutInMillis": 0,
  "tlsConfig": {
    "insecureSkipVerification": ""
  }
}' |  \
  http PUT {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "type": "",\n  "httpMethod": "",\n  "uri": "",\n  "connectionType": "",\n  "connectionId": "",\n  "credentials": "",\n  "requestParameters": {},\n  "requestTemplates": {},\n  "passthroughBehavior": "",\n  "cacheNamespace": "",\n  "cacheKeyParameters": [],\n  "contentHandling": "",\n  "timeoutInMillis": 0,\n  "tlsConfig": {\n    "insecureSkipVerification": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "type": "",
  "httpMethod": "",
  "uri": "",
  "connectionType": "",
  "connectionId": "",
  "credentials": "",
  "requestParameters": [],
  "requestTemplates": [],
  "passthroughBehavior": "",
  "cacheNamespace": "",
  "cacheKeyParameters": [],
  "contentHandling": "",
  "timeoutInMillis": 0,
  "tlsConfig": ["insecureSkipVerification": ""]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")! 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()

PUT PutIntegrationResponse

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

QUERY PARAMS

restapi_id

resource_id

http_method

status_code

BODY json

{
  "selectionPattern": "",
  "responseParameters": {},
  "responseTemplates": {},
  "contentHandling": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code");

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  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code" {:content-type :json
                                                                                                                                               :form-params {:selectionPattern ""
                                                                                                                                                             :responseParameters {}
                                                                                                                                                             :responseTemplates {}
                                                                                                                                                             :contentHandling ""}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"),
    Content = new StringContent("{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

	payload := strings.NewReader("{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 108

{
  "selectionPattern": "",
  "responseParameters": {},
  "responseTemplates": {},
  "contentHandling": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\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  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .header("content-type", "application/json")
  .body("{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  selectionPattern: '',
  responseParameters: {},
  responseTemplates: {},
  contentHandling: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  headers: {'content-type': 'application/json'},
  data: {
    selectionPattern: '',
    responseParameters: {},
    responseTemplates: {},
    contentHandling: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"selectionPattern":"","responseParameters":{},"responseTemplates":{},"contentHandling":""}'
};

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "selectionPattern": "",\n  "responseParameters": {},\n  "responseTemplates": {},\n  "contentHandling": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  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({
  selectionPattern: '',
  responseParameters: {},
  responseTemplates: {},
  contentHandling: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  headers: {'content-type': 'application/json'},
  body: {
    selectionPattern: '',
    responseParameters: {},
    responseTemplates: {},
    contentHandling: ''
  },
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  selectionPattern: '',
  responseParameters: {},
  responseTemplates: {},
  contentHandling: ''
});

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  headers: {'content-type': 'application/json'},
  data: {
    selectionPattern: '',
    responseParameters: {},
    responseTemplates: {},
    contentHandling: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"selectionPattern":"","responseParameters":{},"responseTemplates":{},"contentHandling":""}'
};

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 = @{ @"selectionPattern": @"",
                              @"responseParameters": @{  },
                              @"responseTemplates": @{  },
                              @"contentHandling": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code",
  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([
    'selectionPattern' => '',
    'responseParameters' => [
        
    ],
    'responseTemplates' => [
        
    ],
    'contentHandling' => ''
  ]),
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code', [
  'body' => '{
  "selectionPattern": "",
  "responseParameters": {},
  "responseTemplates": {},
  "contentHandling": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'selectionPattern' => '',
  'responseParameters' => [
    
  ],
  'responseTemplates' => [
    
  ],
  'contentHandling' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'selectionPattern' => '',
  'responseParameters' => [
    
  ],
  'responseTemplates' => [
    
  ],
  'contentHandling' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');
$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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "selectionPattern": "",
  "responseParameters": {},
  "responseTemplates": {},
  "contentHandling": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "selectionPattern": "",
  "responseParameters": {},
  "responseTemplates": {},
  "contentHandling": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

payload = {
    "selectionPattern": "",
    "responseParameters": {},
    "responseTemplates": {},
    "contentHandling": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

payload <- "{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")

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  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code') do |req|
  req.body = "{\n  \"selectionPattern\": \"\",\n  \"responseParameters\": {},\n  \"responseTemplates\": {},\n  \"contentHandling\": \"\"\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code";

    let payload = json!({
        "selectionPattern": "",
        "responseParameters": json!({}),
        "responseTemplates": json!({}),
        "contentHandling": ""
    });

    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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code \
  --header 'content-type: application/json' \
  --data '{
  "selectionPattern": "",
  "responseParameters": {},
  "responseTemplates": {},
  "contentHandling": ""
}'

echo '{
  "selectionPattern": "",
  "responseParameters": {},
  "responseTemplates": {},
  "contentHandling": ""
}' |  \
  http PUT {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "selectionPattern": "",\n  "responseParameters": {},\n  "responseTemplates": {},\n  "contentHandling": ""\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "selectionPattern": "",
  "responseParameters": [],
  "responseTemplates": [],
  "contentHandling": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")! 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()

PUT PutMethod

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

QUERY PARAMS

restapi_id

resource_id

http_method

BODY json

{
  "authorizationType": "",
  "authorizerId": "",
  "apiKeyRequired": false,
  "operationName": "",
  "requestParameters": {},
  "requestModels": {},
  "requestValidatorId": "",
  "authorizationScopes": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method");

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  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method" {:content-type :json
                                                                                                            :form-params {:authorizationType ""
                                                                                                                          :authorizerId ""
                                                                                                                          :apiKeyRequired false
                                                                                                                          :operationName ""
                                                                                                                          :requestParameters {}
                                                                                                                          :requestModels {}
                                                                                                                          :requestValidatorId ""
                                                                                                                          :authorizationScopes []}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"),
    Content = new StringContent("{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

	payload := strings.NewReader("{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\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/restapis/:restapi_id/resources/:resource_id/methods/:http_method HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 208

{
  "authorizationType": "",
  "authorizerId": "",
  "apiKeyRequired": false,
  "operationName": "",
  "requestParameters": {},
  "requestModels": {},
  "requestValidatorId": "",
  "authorizationScopes": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\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  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .header("content-type", "application/json")
  .body("{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\n}")
  .asString();

const data = JSON.stringify({
  authorizationType: '',
  authorizerId: '',
  apiKeyRequired: false,
  operationName: '',
  requestParameters: {},
  requestModels: {},
  requestValidatorId: '',
  authorizationScopes: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  headers: {'content-type': 'application/json'},
  data: {
    authorizationType: '',
    authorizerId: '',
    apiKeyRequired: false,
    operationName: '',
    requestParameters: {},
    requestModels: {},
    requestValidatorId: '',
    authorizationScopes: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authorizationType":"","authorizerId":"","apiKeyRequired":false,"operationName":"","requestParameters":{},"requestModels":{},"requestValidatorId":"","authorizationScopes":[]}'
};

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authorizationType": "",\n  "authorizerId": "",\n  "apiKeyRequired": false,\n  "operationName": "",\n  "requestParameters": {},\n  "requestModels": {},\n  "requestValidatorId": "",\n  "authorizationScopes": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .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/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  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({
  authorizationType: '',
  authorizerId: '',
  apiKeyRequired: false,
  operationName: '',
  requestParameters: {},
  requestModels: {},
  requestValidatorId: '',
  authorizationScopes: []
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  headers: {'content-type': 'application/json'},
  body: {
    authorizationType: '',
    authorizerId: '',
    apiKeyRequired: false,
    operationName: '',
    requestParameters: {},
    requestModels: {},
    requestValidatorId: '',
    authorizationScopes: []
  },
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authorizationType: '',
  authorizerId: '',
  apiKeyRequired: false,
  operationName: '',
  requestParameters: {},
  requestModels: {},
  requestValidatorId: '',
  authorizationScopes: []
});

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  headers: {'content-type': 'application/json'},
  data: {
    authorizationType: '',
    authorizerId: '',
    apiKeyRequired: false,
    operationName: '',
    requestParameters: {},
    requestModels: {},
    requestValidatorId: '',
    authorizationScopes: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"authorizationType":"","authorizerId":"","apiKeyRequired":false,"operationName":"","requestParameters":{},"requestModels":{},"requestValidatorId":"","authorizationScopes":[]}'
};

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 = @{ @"authorizationType": @"",
                              @"authorizerId": @"",
                              @"apiKeyRequired": @NO,
                              @"operationName": @"",
                              @"requestParameters": @{  },
                              @"requestModels": @{  },
                              @"requestValidatorId": @"",
                              @"authorizationScopes": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method",
  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([
    'authorizationType' => '',
    'authorizerId' => '',
    'apiKeyRequired' => null,
    'operationName' => '',
    'requestParameters' => [
        
    ],
    'requestModels' => [
        
    ],
    'requestValidatorId' => '',
    'authorizationScopes' => [
        
    ]
  ]),
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method', [
  'body' => '{
  "authorizationType": "",
  "authorizerId": "",
  "apiKeyRequired": false,
  "operationName": "",
  "requestParameters": {},
  "requestModels": {},
  "requestValidatorId": "",
  "authorizationScopes": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authorizationType' => '',
  'authorizerId' => '',
  'apiKeyRequired' => null,
  'operationName' => '',
  'requestParameters' => [
    
  ],
  'requestModels' => [
    
  ],
  'requestValidatorId' => '',
  'authorizationScopes' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'authorizationType' => '',
  'authorizerId' => '',
  'apiKeyRequired' => null,
  'operationName' => '',
  'requestParameters' => [
    
  ],
  'requestModels' => [
    
  ],
  'requestValidatorId' => '',
  'authorizationScopes' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
$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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authorizationType": "",
  "authorizerId": "",
  "apiKeyRequired": false,
  "operationName": "",
  "requestParameters": {},
  "requestModels": {},
  "requestValidatorId": "",
  "authorizationScopes": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "authorizationType": "",
  "authorizerId": "",
  "apiKeyRequired": false,
  "operationName": "",
  "requestParameters": {},
  "requestModels": {},
  "requestValidatorId": "",
  "authorizationScopes": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

payload = {
    "authorizationType": "",
    "authorizerId": "",
    "apiKeyRequired": False,
    "operationName": "",
    "requestParameters": {},
    "requestModels": {},
    "requestValidatorId": "",
    "authorizationScopes": []
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

payload <- "{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")

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  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\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/restapis/:restapi_id/resources/:resource_id/methods/:http_method') do |req|
  req.body = "{\n  \"authorizationType\": \"\",\n  \"authorizerId\": \"\",\n  \"apiKeyRequired\": false,\n  \"operationName\": \"\",\n  \"requestParameters\": {},\n  \"requestModels\": {},\n  \"requestValidatorId\": \"\",\n  \"authorizationScopes\": []\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method";

    let payload = json!({
        "authorizationType": "",
        "authorizerId": "",
        "apiKeyRequired": false,
        "operationName": "",
        "requestParameters": json!({}),
        "requestModels": json!({}),
        "requestValidatorId": "",
        "authorizationScopes": ()
    });

    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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method \
  --header 'content-type: application/json' \
  --data '{
  "authorizationType": "",
  "authorizerId": "",
  "apiKeyRequired": false,
  "operationName": "",
  "requestParameters": {},
  "requestModels": {},
  "requestValidatorId": "",
  "authorizationScopes": []
}'

echo '{
  "authorizationType": "",
  "authorizerId": "",
  "apiKeyRequired": false,
  "operationName": "",
  "requestParameters": {},
  "requestModels": {},
  "requestValidatorId": "",
  "authorizationScopes": []
}' |  \
  http PUT {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "authorizationType": "",\n  "authorizerId": "",\n  "apiKeyRequired": false,\n  "operationName": "",\n  "requestParameters": {},\n  "requestModels": {},\n  "requestValidatorId": "",\n  "authorizationScopes": []\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authorizationType": "",
  "authorizerId": "",
  "apiKeyRequired": false,
  "operationName": "",
  "requestParameters": [],
  "requestModels": [],
  "requestValidatorId": "",
  "authorizationScopes": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")! 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()

PUT PutMethodResponse

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

QUERY PARAMS

restapi_id

resource_id

http_method

status_code

BODY json

{
  "responseParameters": {},
  "responseModels": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code");

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  \"responseParameters\": {},\n  \"responseModels\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code" {:content-type :json
                                                                                                                                   :form-params {:responseParameters {}
                                                                                                                                                 :responseModels {}}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"responseParameters\": {},\n  \"responseModels\": {}\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"),
    Content = new StringContent("{\n  \"responseParameters\": {},\n  \"responseModels\": {}\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"responseParameters\": {},\n  \"responseModels\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

	payload := strings.NewReader("{\n  \"responseParameters\": {},\n  \"responseModels\": {}\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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "responseParameters": {},
  "responseModels": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"responseParameters\": {},\n  \"responseModels\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"responseParameters\": {},\n  \"responseModels\": {}\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  \"responseParameters\": {},\n  \"responseModels\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .header("content-type", "application/json")
  .body("{\n  \"responseParameters\": {},\n  \"responseModels\": {}\n}")
  .asString();

const data = JSON.stringify({
  responseParameters: {},
  responseModels: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  headers: {'content-type': 'application/json'},
  data: {responseParameters: {}, responseModels: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"responseParameters":{},"responseModels":{}}'
};

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "responseParameters": {},\n  "responseModels": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"responseParameters\": {},\n  \"responseModels\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  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({responseParameters: {}, responseModels: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  headers: {'content-type': 'application/json'},
  body: {responseParameters: {}, responseModels: {}},
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  responseParameters: {},
  responseModels: {}
});

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  headers: {'content-type': 'application/json'},
  data: {responseParameters: {}, responseModels: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"responseParameters":{},"responseModels":{}}'
};

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 = @{ @"responseParameters": @{  },
                              @"responseModels": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"responseParameters\": {},\n  \"responseModels\": {}\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code",
  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([
    'responseParameters' => [
        
    ],
    'responseModels' => [
        
    ]
  ]),
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code', [
  'body' => '{
  "responseParameters": {},
  "responseModels": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'responseParameters' => [
    
  ],
  'responseModels' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'responseParameters' => [
    
  ],
  'responseModels' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');
$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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "responseParameters": {},
  "responseModels": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "responseParameters": {},
  "responseModels": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"responseParameters\": {},\n  \"responseModels\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

payload = {
    "responseParameters": {},
    "responseModels": {}
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

payload <- "{\n  \"responseParameters\": {},\n  \"responseModels\": {}\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")

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  \"responseParameters\": {},\n  \"responseModels\": {}\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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code') do |req|
  req.body = "{\n  \"responseParameters\": {},\n  \"responseModels\": {}\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code";

    let payload = json!({
        "responseParameters": json!({}),
        "responseModels": 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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code \
  --header 'content-type: application/json' \
  --data '{
  "responseParameters": {},
  "responseModels": {}
}'

echo '{
  "responseParameters": {},
  "responseModels": {}
}' |  \
  http PUT {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "responseParameters": {},\n  "responseModels": {}\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "responseParameters": [],
  "responseModels": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")! 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()

PUT PutRestApi

{{baseUrl}}/restapis/:restapi_id

QUERY PARAMS

restapi_id

BODY json

{
  "body": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"body\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restapis/:restapi_id" {:content-type :json
                                                                :form-params {:body ""}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"body\": \"\"\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}}/restapis/:restapi_id"),
    Content = new StringContent("{\n  \"body\": \"\"\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}}/restapis/:restapi_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"body\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id"

	payload := strings.NewReader("{\n  \"body\": \"\"\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/restapis/:restapi_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "body": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restapis/:restapi_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"body\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"body\": \"\"\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  \"body\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restapis/:restapi_id")
  .header("content-type", "application/json")
  .body("{\n  \"body\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  body: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restapis/:restapi_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id',
  headers: {'content-type': 'application/json'},
  data: {body: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"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}}/restapis/:restapi_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "body": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"body\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({body: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restapis/:restapi_id',
  headers: {'content-type': 'application/json'},
  body: {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}}/restapis/:restapi_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  body: ''
});

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}}/restapis/:restapi_id',
  headers: {'content-type': 'application/json'},
  data: {body: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"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 = @{ @"body": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"body\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'body' => ''
  ]),
  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}}/restapis/:restapi_id', [
  'body' => '{
  "body": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'body' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'body' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "body": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "body": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"body\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restapis/:restapi_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id"

payload = { "body": "" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id"

payload <- "{\n  \"body\": \"\"\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}}/restapis/:restapi_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"body\": \"\"\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/restapis/:restapi_id') do |req|
  req.body = "{\n  \"body\": \"\"\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}}/restapis/:restapi_id";

    let payload = json!({"body": ""});

    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}}/restapis/:restapi_id \
  --header 'content-type: application/json' \
  --data '{
  "body": ""
}'

echo '{
  "body": ""
}' |  \
  http PUT {{baseUrl}}/restapis/:restapi_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "body": ""\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["body": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT TagResource

{{baseUrl}}/tags/:resource_arn

QUERY PARAMS

resource_arn

BODY json

{
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resource_arn");

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  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/tags/:resource_arn" {:content-type :json
                                                              :form-params {:tags {}}})

require "http/client"

url = "{{baseUrl}}/tags/:resource_arn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tags\": {}\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}}/tags/:resource_arn"),
    Content = new StringContent("{\n  \"tags\": {}\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}}/tags/:resource_arn");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resource_arn"

	payload := strings.NewReader("{\n  \"tags\": {}\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/tags/:resource_arn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/tags/:resource_arn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resource_arn"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"tags\": {}\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  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resource_arn")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/tags/:resource_arn")
  .header("content-type", "application/json")
  .body("{\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  tags: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/tags/:resource_arn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/tags/:resource_arn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resource_arn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

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}}/tags/:resource_arn',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tags": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resource_arn")
  .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/tags/:resource_arn',
  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({tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/tags/:resource_arn',
  headers: {'content-type': 'application/json'},
  body: {tags: {}},
  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}}/tags/:resource_arn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  tags: {}
});

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}}/tags/:resource_arn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resource_arn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

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 = @{ @"tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resource_arn"]
                                                       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}}/tags/:resource_arn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tags\": {}\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resource_arn",
  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([
    'tags' => [
        
    ]
  ]),
  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}}/tags/:resource_arn', [
  'body' => '{
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resource_arn');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/tags/:resource_arn');
$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}}/tags/:resource_arn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resource_arn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/tags/:resource_arn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resource_arn"

payload = { "tags": {} }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resource_arn"

payload <- "{\n  \"tags\": {}\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}}/tags/:resource_arn")

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  \"tags\": {}\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/tags/:resource_arn') do |req|
  req.body = "{\n  \"tags\": {}\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}}/tags/:resource_arn";

    let payload = json!({"tags": 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}}/tags/:resource_arn \
  --header 'content-type: application/json' \
  --data '{
  "tags": {}
}'

echo '{
  "tags": {}
}' |  \
  http PUT {{baseUrl}}/tags/:resource_arn \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/tags/:resource_arn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["tags": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resource_arn")! 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()

POST TestInvokeAuthorizer

{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

QUERY PARAMS

restapi_id

authorizer_id

BODY json

{
  "headers": {},
  "multiValueHeaders": {},
  "pathWithQueryString": "",
  "body": "",
  "stageVariables": {},
  "additionalContext": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id" {:content-type :json
                                                                                            :form-params {:headers {}
                                                                                                          :multiValueHeaders {}
                                                                                                          :pathWithQueryString ""
                                                                                                          :body ""
                                                                                                          :stageVariables {}
                                                                                                          :additionalContext {}}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"),
    Content = new StringContent("{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\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}}/restapis/:restapi_id/authorizers/:authorizer_id");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

	payload := strings.NewReader("{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/restapis/:restapi_id/authorizers/:authorizer_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 140

{
  "headers": {},
  "multiValueHeaders": {},
  "pathWithQueryString": "",
  "body": "",
  "stageVariables": {},
  "additionalContext": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\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  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .header("content-type", "application/json")
  .body("{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}")
  .asString();

const data = JSON.stringify({
  headers: {},
  multiValueHeaders: {},
  pathWithQueryString: '',
  body: '',
  stageVariables: {},
  additionalContext: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id',
  headers: {'content-type': 'application/json'},
  data: {
    headers: {},
    multiValueHeaders: {},
    pathWithQueryString: '',
    body: '',
    stageVariables: {},
    additionalContext: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"headers":{},"multiValueHeaders":{},"pathWithQueryString":"","body":"","stageVariables":{},"additionalContext":{}}'
};

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}}/restapis/:restapi_id/authorizers/:authorizer_id',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "headers": {},\n  "multiValueHeaders": {},\n  "pathWithQueryString": "",\n  "body": "",\n  "stageVariables": {},\n  "additionalContext": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .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/restapis/:restapi_id/authorizers/:authorizer_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  headers: {},
  multiValueHeaders: {},
  pathWithQueryString: '',
  body: '',
  stageVariables: {},
  additionalContext: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id',
  headers: {'content-type': 'application/json'},
  body: {
    headers: {},
    multiValueHeaders: {},
    pathWithQueryString: '',
    body: '',
    stageVariables: {},
    additionalContext: {}
  },
  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}}/restapis/:restapi_id/authorizers/:authorizer_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  headers: {},
  multiValueHeaders: {},
  pathWithQueryString: '',
  body: '',
  stageVariables: {},
  additionalContext: {}
});

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}}/restapis/:restapi_id/authorizers/:authorizer_id',
  headers: {'content-type': 'application/json'},
  data: {
    headers: {},
    multiValueHeaders: {},
    pathWithQueryString: '',
    body: '',
    stageVariables: {},
    additionalContext: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"headers":{},"multiValueHeaders":{},"pathWithQueryString":"","body":"","stageVariables":{},"additionalContext":{}}'
};

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 = @{ @"headers": @{  },
                              @"multiValueHeaders": @{  },
                              @"pathWithQueryString": @"",
                              @"body": @"",
                              @"stageVariables": @{  },
                              @"additionalContext": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"]
                                                       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}}/restapis/:restapi_id/authorizers/:authorizer_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id",
  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([
    'headers' => [
        
    ],
    'multiValueHeaders' => [
        
    ],
    'pathWithQueryString' => '',
    'body' => '',
    'stageVariables' => [
        
    ],
    'additionalContext' => [
        
    ]
  ]),
  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}}/restapis/:restapi_id/authorizers/:authorizer_id', [
  'body' => '{
  "headers": {},
  "multiValueHeaders": {},
  "pathWithQueryString": "",
  "body": "",
  "stageVariables": {},
  "additionalContext": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'headers' => [
    
  ],
  'multiValueHeaders' => [
    
  ],
  'pathWithQueryString' => '',
  'body' => '',
  'stageVariables' => [
    
  ],
  'additionalContext' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'headers' => [
    
  ],
  'multiValueHeaders' => [
    
  ],
  'pathWithQueryString' => '',
  'body' => '',
  'stageVariables' => [
    
  ],
  'additionalContext' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');
$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}}/restapis/:restapi_id/authorizers/:authorizer_id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "headers": {},
  "multiValueHeaders": {},
  "pathWithQueryString": "",
  "body": "",
  "stageVariables": {},
  "additionalContext": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "headers": {},
  "multiValueHeaders": {},
  "pathWithQueryString": "",
  "body": "",
  "stageVariables": {},
  "additionalContext": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restapis/:restapi_id/authorizers/:authorizer_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

payload = {
    "headers": {},
    "multiValueHeaders": {},
    "pathWithQueryString": "",
    "body": "",
    "stageVariables": {},
    "additionalContext": {}
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

payload <- "{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restapis/:restapi_id/authorizers/:authorizer_id') do |req|
  req.body = "{\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"stageVariables\": {},\n  \"additionalContext\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id";

    let payload = json!({
        "headers": json!({}),
        "multiValueHeaders": json!({}),
        "pathWithQueryString": "",
        "body": "",
        "stageVariables": json!({}),
        "additionalContext": 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}}/restapis/:restapi_id/authorizers/:authorizer_id \
  --header 'content-type: application/json' \
  --data '{
  "headers": {},
  "multiValueHeaders": {},
  "pathWithQueryString": "",
  "body": "",
  "stageVariables": {},
  "additionalContext": {}
}'

echo '{
  "headers": {},
  "multiValueHeaders": {},
  "pathWithQueryString": "",
  "body": "",
  "stageVariables": {},
  "additionalContext": {}
}' |  \
  http POST {{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "headers": {},\n  "multiValueHeaders": {},\n  "pathWithQueryString": "",\n  "body": "",\n  "stageVariables": {},\n  "additionalContext": {}\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "headers": [],
  "multiValueHeaders": [],
  "pathWithQueryString": "",
  "body": "",
  "stageVariables": [],
  "additionalContext": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST TestInvokeMethod

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

QUERY PARAMS

restapi_id

resource_id

http_method

BODY json

{
  "pathWithQueryString": "",
  "body": "",
  "headers": {},
  "multiValueHeaders": {},
  "clientCertificateId": "",
  "stageVariables": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method");

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  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method" {:content-type :json
                                                                                                             :form-params {:pathWithQueryString ""
                                                                                                                           :body ""
                                                                                                                           :headers {}
                                                                                                                           :multiValueHeaders {}
                                                                                                                           :clientCertificateId ""
                                                                                                                           :stageVariables {}}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"),
    Content = new StringContent("{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

	payload := strings.NewReader("{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 142

{
  "pathWithQueryString": "",
  "body": "",
  "headers": {},
  "multiValueHeaders": {},
  "clientCertificateId": "",
  "stageVariables": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\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  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .header("content-type", "application/json")
  .body("{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}")
  .asString();

const data = JSON.stringify({
  pathWithQueryString: '',
  body: '',
  headers: {},
  multiValueHeaders: {},
  clientCertificateId: '',
  stageVariables: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  headers: {'content-type': 'application/json'},
  data: {
    pathWithQueryString: '',
    body: '',
    headers: {},
    multiValueHeaders: {},
    clientCertificateId: '',
    stageVariables: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pathWithQueryString":"","body":"","headers":{},"multiValueHeaders":{},"clientCertificateId":"","stageVariables":{}}'
};

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "pathWithQueryString": "",\n  "body": "",\n  "headers": {},\n  "multiValueHeaders": {},\n  "clientCertificateId": "",\n  "stageVariables": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .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/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  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({
  pathWithQueryString: '',
  body: '',
  headers: {},
  multiValueHeaders: {},
  clientCertificateId: '',
  stageVariables: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  headers: {'content-type': 'application/json'},
  body: {
    pathWithQueryString: '',
    body: '',
    headers: {},
    multiValueHeaders: {},
    clientCertificateId: '',
    stageVariables: {}
  },
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  pathWithQueryString: '',
  body: '',
  headers: {},
  multiValueHeaders: {},
  clientCertificateId: '',
  stageVariables: {}
});

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  headers: {'content-type': 'application/json'},
  data: {
    pathWithQueryString: '',
    body: '',
    headers: {},
    multiValueHeaders: {},
    clientCertificateId: '',
    stageVariables: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"pathWithQueryString":"","body":"","headers":{},"multiValueHeaders":{},"clientCertificateId":"","stageVariables":{}}'
};

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 = @{ @"pathWithQueryString": @"",
                              @"body": @"",
                              @"headers": @{  },
                              @"multiValueHeaders": @{  },
                              @"clientCertificateId": @"",
                              @"stageVariables": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method",
  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([
    'pathWithQueryString' => '',
    'body' => '',
    'headers' => [
        
    ],
    'multiValueHeaders' => [
        
    ],
    'clientCertificateId' => '',
    'stageVariables' => [
        
    ]
  ]),
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method', [
  'body' => '{
  "pathWithQueryString": "",
  "body": "",
  "headers": {},
  "multiValueHeaders": {},
  "clientCertificateId": "",
  "stageVariables": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'pathWithQueryString' => '',
  'body' => '',
  'headers' => [
    
  ],
  'multiValueHeaders' => [
    
  ],
  'clientCertificateId' => '',
  'stageVariables' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'pathWithQueryString' => '',
  'body' => '',
  'headers' => [
    
  ],
  'multiValueHeaders' => [
    
  ],
  'clientCertificateId' => '',
  'stageVariables' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
$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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pathWithQueryString": "",
  "body": "",
  "headers": {},
  "multiValueHeaders": {},
  "clientCertificateId": "",
  "stageVariables": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "pathWithQueryString": "",
  "body": "",
  "headers": {},
  "multiValueHeaders": {},
  "clientCertificateId": "",
  "stageVariables": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

payload = {
    "pathWithQueryString": "",
    "body": "",
    "headers": {},
    "multiValueHeaders": {},
    "clientCertificateId": "",
    "stageVariables": {}
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

payload <- "{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method') do |req|
  req.body = "{\n  \"pathWithQueryString\": \"\",\n  \"body\": \"\",\n  \"headers\": {},\n  \"multiValueHeaders\": {},\n  \"clientCertificateId\": \"\",\n  \"stageVariables\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method";

    let payload = json!({
        "pathWithQueryString": "",
        "body": "",
        "headers": json!({}),
        "multiValueHeaders": json!({}),
        "clientCertificateId": "",
        "stageVariables": 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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method \
  --header 'content-type: application/json' \
  --data '{
  "pathWithQueryString": "",
  "body": "",
  "headers": {},
  "multiValueHeaders": {},
  "clientCertificateId": "",
  "stageVariables": {}
}'

echo '{
  "pathWithQueryString": "",
  "body": "",
  "headers": {},
  "multiValueHeaders": {},
  "clientCertificateId": "",
  "stageVariables": {}
}' |  \
  http POST {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "pathWithQueryString": "",\n  "body": "",\n  "headers": {},\n  "multiValueHeaders": {},\n  "clientCertificateId": "",\n  "stageVariables": {}\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "pathWithQueryString": "",
  "body": "",
  "headers": [],
  "multiValueHeaders": [],
  "clientCertificateId": "",
  "stageVariables": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE UntagResource

{{baseUrl}}/tags/:resource_arn#tagKeys

QUERY PARAMS

tagKeys

resource_arn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/tags/:resource_arn#tagKeys" {:query-params {:tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys"

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}}/tags/:resource_arn?tagKeys=#tagKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys"

	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/tags/:resource_arn?tagKeys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys"))
    .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}}/tags/:resource_arn?tagKeys=#tagKeys")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys")
  .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}}/tags/:resource_arn?tagKeys=#tagKeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resource_arn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys';
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}}/tags/:resource_arn?tagKeys=#tagKeys',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resource_arn?tagKeys=',
  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}}/tags/:resource_arn#tagKeys',
  qs: {tagKeys: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tags/:resource_arn#tagKeys');

req.query({
  tagKeys: ''
});

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}}/tags/:resource_arn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys';
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}}/tags/:resource_arn?tagKeys=#tagKeys"]
                                                       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}}/tags/:resource_arn?tagKeys=#tagKeys" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys",
  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}}/tags/:resource_arn?tagKeys=#tagKeys');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resource_arn#tagKeys');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'tagKeys' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags/:resource_arn#tagKeys');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'tagKeys' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/tags/:resource_arn?tagKeys=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resource_arn#tagKeys"

querystring = {"tagKeys":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resource_arn#tagKeys"

queryString <- list(tagKeys = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys")

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/tags/:resource_arn') do |req|
  req.params['tagKeys'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resource_arn#tagKeys";

    let querystring = [
        ("tagKeys", ""),
    ];

    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}}/tags/:resource_arn?tagKeys=#tagKeys'

http DELETE '{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resource_arn?tagKeys=#tagKeys")! 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()

PATCH UpdateAccount

{{baseUrl}}/account

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account");

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/account" {:content-type :json
                                                     :form-params {:patchOperations [{:op ""
                                                                                      :path ""
                                                                                      :value ""
                                                                                      :from ""}]}})

require "http/client"

url = "{{baseUrl}}/account"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/account"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/account HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/account")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/account")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/account');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/account',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/account',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account")
  .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/account',
  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({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/account',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/account');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/account',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account"]
                                                       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}}/account" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account",
  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([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/account', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account');
$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}}/account' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/account", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/account")

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/account') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/account";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/account \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/account \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/account

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account")! 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()

PATCH UpdateApiKey

{{baseUrl}}/apikeys/:api_Key

QUERY PARAMS

api_Key

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/apikeys/:api_Key");

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/apikeys/:api_Key" {:content-type :json
                                                              :form-params {:patchOperations [{:op ""
                                                                                               :path ""
                                                                                               :value ""
                                                                                               :from ""}]}})

require "http/client"

url = "{{baseUrl}}/apikeys/:api_Key"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/apikeys/:api_Key"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/apikeys/:api_Key");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/apikeys/:api_Key"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/apikeys/:api_Key HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/apikeys/:api_Key")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/apikeys/:api_Key"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/apikeys/:api_Key")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/apikeys/:api_Key")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/apikeys/:api_Key');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/apikeys/:api_Key',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/apikeys/:api_Key';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/apikeys/:api_Key',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/apikeys/:api_Key")
  .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/apikeys/:api_Key',
  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({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/apikeys/:api_Key',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/apikeys/:api_Key');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/apikeys/:api_Key',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/apikeys/:api_Key';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/apikeys/:api_Key"]
                                                       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}}/apikeys/:api_Key" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/apikeys/:api_Key",
  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([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/apikeys/:api_Key', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/apikeys/:api_Key');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/apikeys/:api_Key');
$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}}/apikeys/:api_Key' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/apikeys/:api_Key' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/apikeys/:api_Key", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/apikeys/:api_Key"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/apikeys/:api_Key"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/apikeys/:api_Key")

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/apikeys/:api_Key') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/apikeys/:api_Key";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/apikeys/:api_Key \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/apikeys/:api_Key \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/apikeys/:api_Key

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/apikeys/:api_Key")! 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()

PATCH UpdateAuthorizer

{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

QUERY PARAMS

restapi_id

authorizer_id

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id" {:content-type :json
                                                                                             :form-params {:patchOperations [{:op ""
                                                                                                                              :path ""
                                                                                                                              :value ""
                                                                                                                              :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/authorizers/:authorizer_id"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/authorizers/:authorizer_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/authorizers/:authorizer_id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/authorizers/:authorizer_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/authorizers/:authorizer_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/authorizers/:authorizer_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/authorizers/:authorizer_id', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/authorizers/:authorizer_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/authorizers/:authorizer_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/authorizers/:authorizer_id') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/authorizers/:authorizer_id";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/authorizers/:authorizer_id \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/authorizers/:authorizer_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH UpdateBasePathMapping

{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path

QUERY PARAMS

domain_name

base_path

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path");

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path" {:content-type :json
                                                                                                  :form-params {:patchOperations [{:op ""
                                                                                                                                   :path ""
                                                                                                                                   :value ""
                                                                                                                                   :from ""}]}})

require "http/client"

url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/domainnames/:domain_name/basepathmappings/:base_path"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/domainnames/:domain_name/basepathmappings/:base_path HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/domainnames/:domain_name/basepathmappings/:base_path',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")
  .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/domainnames/:domain_name/basepathmappings/:base_path',
  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({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/domainnames/:domain_name/basepathmappings/:base_path');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/domainnames/:domain_name/basepathmappings/:base_path',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"]
                                                       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}}/domainnames/:domain_name/basepathmappings/:base_path" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path",
  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([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/domainnames/:domain_name/basepathmappings/:base_path', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path');
$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}}/domainnames/:domain_name/basepathmappings/:base_path' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/domainnames/:domain_name/basepathmappings/:base_path", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/domainnames/:domain_name/basepathmappings/:base_path")

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/domainnames/:domain_name/basepathmappings/:base_path') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/domainnames/:domain_name/basepathmappings/:base_path";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/domainnames/:domain_name/basepathmappings/:base_path \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domainnames/:domain_name/basepathmappings/:base_path")! 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()

PATCH UpdateClientCertificate

{{baseUrl}}/clientcertificates/:clientcertificate_id

QUERY PARAMS

clientcertificate_id

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clientcertificates/:clientcertificate_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/clientcertificates/:clientcertificate_id" {:content-type :json
                                                                                      :form-params {:patchOperations [{:op ""
                                                                                                                       :path ""
                                                                                                                       :value ""
                                                                                                                       :from ""}]}})

require "http/client"

url = "{{baseUrl}}/clientcertificates/:clientcertificate_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/clientcertificates/:clientcertificate_id"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clientcertificates/:clientcertificate_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clientcertificates/:clientcertificate_id"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/clientcertificates/:clientcertificate_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/clientcertificates/:clientcertificate_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clientcertificates/:clientcertificate_id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clientcertificates/:clientcertificate_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/clientcertificates/:clientcertificate_id")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/clientcertificates/:clientcertificate_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/clientcertificates/:clientcertificate_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clientcertificates/:clientcertificate_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/clientcertificates/:clientcertificate_id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clientcertificates/:clientcertificate_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clientcertificates/:clientcertificate_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/clientcertificates/:clientcertificate_id',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/clientcertificates/:clientcertificate_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/clientcertificates/:clientcertificate_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clientcertificates/:clientcertificate_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clientcertificates/:clientcertificate_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clientcertificates/:clientcertificate_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clientcertificates/:clientcertificate_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/clientcertificates/:clientcertificate_id', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clientcertificates/:clientcertificate_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/clientcertificates/:clientcertificate_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clientcertificates/:clientcertificate_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clientcertificates/:clientcertificate_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/clientcertificates/:clientcertificate_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clientcertificates/:clientcertificate_id"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clientcertificates/:clientcertificate_id"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/clientcertificates/:clientcertificate_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/clientcertificates/:clientcertificate_id') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/clientcertificates/:clientcertificate_id";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/clientcertificates/:clientcertificate_id \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/clientcertificates/:clientcertificate_id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/clientcertificates/:clientcertificate_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clientcertificates/:clientcertificate_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH UpdateDeployment

{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id

QUERY PARAMS

restapi_id

deployment_id

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id" {:content-type :json
                                                                                             :form-params {:patchOperations [{:op ""
                                                                                                                              :path ""
                                                                                                                              :value ""
                                                                                                                              :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/deployments/:deployment_id"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/deployments/:deployment_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/deployments/:deployment_id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/deployments/:deployment_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/deployments/:deployment_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/deployments/:deployment_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/deployments/:deployment_id', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/deployments/:deployment_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/deployments/:deployment_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/deployments/:deployment_id') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/deployments/:deployment_id";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/deployments/:deployment_id \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/deployments/:deployment_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH UpdateDocumentationPart

{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id

QUERY PARAMS

restapi_id

part_id

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id" {:content-type :json
                                                                                               :form-params {:patchOperations [{:op ""
                                                                                                                                :path ""
                                                                                                                                :value ""
                                                                                                                                :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/documentation/parts/:part_id"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/documentation/parts/:part_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/documentation/parts/:part_id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/documentation/parts/:part_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/documentation/parts/:part_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/documentation/parts/:part_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/documentation/parts/:part_id', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/documentation/parts/:part_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/documentation/parts/:part_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/documentation/parts/:part_id') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/documentation/parts/:part_id";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/documentation/parts/:part_id \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/documentation/parts/:part_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH UpdateDocumentationVersion

{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version

QUERY PARAMS

restapi_id

doc_version

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version");

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version" {:content-type :json
                                                                                                      :form-params {:patchOperations [{:op ""
                                                                                                                                       :path ""
                                                                                                                                       :value ""
                                                                                                                                       :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/documentation/versions/:doc_version"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/documentation/versions/:doc_version HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/documentation/versions/:doc_version',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")
  .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/restapis/:restapi_id/documentation/versions/:doc_version',
  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({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/documentation/versions/:doc_version');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/documentation/versions/:doc_version',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"]
                                                       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}}/restapis/:restapi_id/documentation/versions/:doc_version" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version",
  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([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/documentation/versions/:doc_version', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version');
$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}}/restapis/:restapi_id/documentation/versions/:doc_version' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/documentation/versions/:doc_version", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/documentation/versions/:doc_version")

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/documentation/versions/:doc_version') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/documentation/versions/:doc_version";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/documentation/versions/:doc_version \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/documentation/versions/:doc_version")! 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()

PATCH UpdateDomainName

{{baseUrl}}/domainnames/:domain_name

QUERY PARAMS

domain_name

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domainnames/:domain_name");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/domainnames/:domain_name" {:content-type :json
                                                                      :form-params {:patchOperations [{:op ""
                                                                                                       :path ""
                                                                                                       :value ""
                                                                                                       :from ""}]}})

require "http/client"

url = "{{baseUrl}}/domainnames/:domain_name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/domainnames/:domain_name"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domainnames/:domain_name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domainnames/:domain_name"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/domainnames/:domain_name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/domainnames/:domain_name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domainnames/:domain_name"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/domainnames/:domain_name")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/domainnames/:domain_name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/domainnames/:domain_name',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domainnames/:domain_name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/domainnames/:domain_name',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domainnames/:domain_name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domainnames/:domain_name',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/domainnames/:domain_name',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/domainnames/:domain_name');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/domainnames/:domain_name',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domainnames/:domain_name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domainnames/:domain_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/domainnames/:domain_name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domainnames/:domain_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/domainnames/:domain_name', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domainnames/:domain_name');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domainnames/:domain_name');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/domainnames/:domain_name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainnames/:domain_name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/domainnames/:domain_name", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domainnames/:domain_name"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domainnames/:domain_name"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/domainnames/:domain_name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/domainnames/:domain_name') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/domainnames/:domain_name";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/domainnames/:domain_name \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/domainnames/:domain_name \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/domainnames/:domain_name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domainnames/:domain_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH UpdateGatewayResponse

{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type

QUERY PARAMS

restapi_id

response_type

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type");

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type" {:content-type :json
                                                                                                  :form-params {:patchOperations [{:op ""
                                                                                                                                   :path ""
                                                                                                                                   :value ""
                                                                                                                                   :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/gatewayresponses/:response_type"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/gatewayresponses/:response_type HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/gatewayresponses/:response_type',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")
  .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/restapis/:restapi_id/gatewayresponses/:response_type',
  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({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/gatewayresponses/:response_type');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/gatewayresponses/:response_type',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"]
                                                       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}}/restapis/:restapi_id/gatewayresponses/:response_type" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type",
  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([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/gatewayresponses/:response_type', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type');
$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}}/restapis/:restapi_id/gatewayresponses/:response_type' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/gatewayresponses/:response_type", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/gatewayresponses/:response_type")

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/gatewayresponses/:response_type') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/gatewayresponses/:response_type";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/gatewayresponses/:response_type \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/gatewayresponses/:response_type")! 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()

PATCH UpdateIntegration

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

QUERY PARAMS

restapi_id

resource_id

http_method

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration");

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration" {:content-type :json
                                                                                                                          :form-params {:patchOperations [{:op ""
                                                                                                                                                           :path ""
                                                                                                                                                           :value ""
                                                                                                                                                           :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")
  .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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  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({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration",
  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([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration');
$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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration")! 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()

PATCH UpdateIntegrationResponse

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

QUERY PARAMS

restapi_id

resource_id

http_method

status_code

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code");

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code" {:content-type :json
                                                                                                                                                 :form-params {:patchOperations [{:op ""
                                                                                                                                                                                  :path ""
                                                                                                                                                                                  :value ""
                                                                                                                                                                                  :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")
  .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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  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({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code",
  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([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code');
$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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/integration/responses/:status_code")! 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()

PATCH UpdateMethod

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

QUERY PARAMS

restapi_id

resource_id

http_method

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method");

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method" {:content-type :json
                                                                                                              :form-params {:patchOperations [{:op ""
                                                                                                                                               :path ""
                                                                                                                                               :value ""
                                                                                                                                               :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/resources/:resource_id/methods/:http_method HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")
  .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/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  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({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method",
  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([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method');
$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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method")! 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()

PATCH UpdateMethodResponse

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

QUERY PARAMS

restapi_id

resource_id

http_method

status_code

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code");

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code" {:content-type :json
                                                                                                                                     :form-params {:patchOperations [{:op ""
                                                                                                                                                                      :path ""
                                                                                                                                                                      :value ""
                                                                                                                                                                      :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")
  .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/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  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({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"]
                                                       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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code",
  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([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code');
$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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id/methods/:http_method/responses/:status_code")! 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()

PATCH UpdateModel

{{baseUrl}}/restapis/:restapi_id/models/:model_name

QUERY PARAMS

restapi_id

model_name

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/models/:model_name");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/models/:model_name" {:content-type :json
                                                                                     :form-params {:patchOperations [{:op ""
                                                                                                                      :path ""
                                                                                                                      :value ""
                                                                                                                      :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/models/:model_name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/models/:model_name"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/models/:model_name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/models/:model_name"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/models/:model_name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/models/:model_name"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/models/:model_name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/models/:model_name',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/models/:model_name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/models/:model_name',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/models/:model_name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/models/:model_name',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/models/:model_name',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/models/:model_name');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/models/:model_name',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/models/:model_name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/models/:model_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/models/:model_name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/models/:model_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/models/:model_name', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/models/:model_name');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/models/:model_name');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/models/:model_name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/models/:model_name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/models/:model_name", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/models/:model_name"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/models/:model_name"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/models/:model_name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/models/:model_name') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/models/:model_name";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/models/:model_name \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/models/:model_name \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/models/:model_name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/models/:model_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH UpdateRequestValidator

{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id

QUERY PARAMS

restapi_id

requestvalidator_id

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id" {:content-type :json
                                                                                                         :form-params {:patchOperations [{:op ""
                                                                                                                                          :path ""
                                                                                                                                          :value ""
                                                                                                                                          :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/requestvalidators/:requestvalidator_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/requestvalidators/:requestvalidator_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/requestvalidators/:requestvalidator_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/requestvalidators/:requestvalidator_id') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/requestvalidators/:requestvalidator_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH UpdateResource

{{baseUrl}}/restapis/:restapi_id/resources/:resource_id

QUERY PARAMS

restapi_id

resource_id

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id" {:content-type :json
                                                                                         :form-params {:patchOperations [{:op ""
                                                                                                                          :path ""
                                                                                                                          :value ""
                                                                                                                          :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/resources/:resource_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/resources/:resource_id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/resources/:resource_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/resources/:resource_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/resources/:resource_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/resources/:resource_id', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/resources/:resource_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/resources/:resource_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/resources/:resource_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/resources/:resource_id') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/resources/:resource_id";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/resources/:resource_id \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/resources/:resource_id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/resources/:resource_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/resources/:resource_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH UpdateRestApi

{{baseUrl}}/restapis/:restapi_id

QUERY PARAMS

restapi_id

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id" {:content-type :json
                                                                  :form-params {:patchOperations [{:op ""
                                                                                                   :path ""
                                                                                                   :value ""
                                                                                                   :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH UpdateStage

{{baseUrl}}/restapis/:restapi_id/stages/:stage_name

QUERY PARAMS

restapi_id

stage_name

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name" {:content-type :json
                                                                                     :form-params {:patchOperations [{:op ""
                                                                                                                      :path ""
                                                                                                                      :value ""
                                                                                                                      :from ""}]}})

require "http/client"

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/stages/:stage_name"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/restapis/:restapi_id/stages/:stage_name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/restapis/:restapi_id/stages/:stage_name',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restapis/:restapi_id/stages/:stage_name',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/restapis/:restapi_id/stages/:stage_name');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/restapis/:restapi_id/stages/:stage_name',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/restapis/:restapi_id/stages/:stage_name', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/restapis/:restapi_id/stages/:stage_name');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restapis/:restapi_id/stages/:stage_name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/restapis/:restapi_id/stages/:stage_name", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/stages/:stage_name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/restapis/:restapi_id/stages/:stage_name') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/restapis/:restapi_id/stages/:stage_name";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/restapis/:restapi_id/stages/:stage_name \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/restapis/:restapi_id/stages/:stage_name \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/restapis/:restapi_id/stages/:stage_name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restapis/:restapi_id/stages/:stage_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PATCH UpdateUsage

{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage

QUERY PARAMS

usageplanId

keyId

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage");

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage" {:content-type :json
                                                                                       :form-params {:patchOperations [{:op ""
                                                                                                                        :path ""
                                                                                                                        :value ""
                                                                                                                        :from ""}]}})

require "http/client"

url = "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/usageplans/:usageplanId/keys/:keyId/usage"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/usageplans/:usageplanId/keys/:keyId/usage HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/usageplans/:usageplanId/keys/:keyId/usage',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage")
  .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/usageplans/:usageplanId/keys/:keyId/usage',
  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({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/usageplans/:usageplanId/keys/:keyId/usage');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/usageplans/:usageplanId/keys/:keyId/usage',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage"]
                                                       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}}/usageplans/:usageplanId/keys/:keyId/usage" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage",
  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([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/usageplans/:usageplanId/keys/:keyId/usage', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage');
$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}}/usageplans/:usageplanId/keys/:keyId/usage' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/usageplans/:usageplanId/keys/:keyId/usage", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/usageplans/:usageplanId/keys/:keyId/usage")

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/usageplans/:usageplanId/keys/:keyId/usage') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/usageplans/:usageplanId/keys/:keyId/usage";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/usageplans/:usageplanId/keys/:keyId/usage \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usageplans/:usageplanId/keys/:keyId/usage")! 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()

PATCH UpdateUsagePlan

{{baseUrl}}/usageplans/:usageplanId

QUERY PARAMS

usageplanId

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usageplans/:usageplanId");

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/usageplans/:usageplanId" {:content-type :json
                                                                     :form-params {:patchOperations [{:op ""
                                                                                                      :path ""
                                                                                                      :value ""
                                                                                                      :from ""}]}})

require "http/client"

url = "{{baseUrl}}/usageplans/:usageplanId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/usageplans/:usageplanId"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/usageplans/:usageplanId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/usageplans/:usageplanId"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/usageplans/:usageplanId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/usageplans/:usageplanId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/usageplans/:usageplanId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/usageplans/:usageplanId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/usageplans/:usageplanId")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/usageplans/:usageplanId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/usageplans/:usageplanId',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/usageplans/:usageplanId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/usageplans/:usageplanId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/usageplans/:usageplanId")
  .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/usageplans/:usageplanId',
  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({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/usageplans/:usageplanId',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/usageplans/:usageplanId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/usageplans/:usageplanId',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/usageplans/:usageplanId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/usageplans/:usageplanId"]
                                                       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}}/usageplans/:usageplanId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/usageplans/:usageplanId",
  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([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/usageplans/:usageplanId', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/usageplans/:usageplanId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/usageplans/:usageplanId');
$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}}/usageplans/:usageplanId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/usageplans/:usageplanId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/usageplans/:usageplanId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/usageplans/:usageplanId"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/usageplans/:usageplanId"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/usageplans/:usageplanId")

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  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/usageplans/:usageplanId') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/usageplans/:usageplanId";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/usageplans/:usageplanId \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/usageplans/:usageplanId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/usageplans/:usageplanId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usageplans/:usageplanId")! 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()

PATCH UpdateVpcLink

{{baseUrl}}/vpclinks/:vpclink_id

QUERY PARAMS

vpclink_id

BODY json

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vpclinks/:vpclink_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/vpclinks/:vpclink_id" {:content-type :json
                                                                  :form-params {:patchOperations [{:op ""
                                                                                                   :path ""
                                                                                                   :value ""
                                                                                                   :from ""}]}})

require "http/client"

url = "{{baseUrl}}/vpclinks/:vpclink_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/vpclinks/:vpclink_id"),
    Content = new StringContent("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/vpclinks/:vpclink_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vpclinks/:vpclink_id"

	payload := strings.NewReader("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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/vpclinks/:vpclink_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/vpclinks/:vpclink_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vpclinks/:vpclink_id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vpclinks/:vpclink_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/vpclinks/:vpclink_id")
  .header("content-type", "application/json")
  .body("{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/vpclinks/:vpclink_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/vpclinks/:vpclink_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/vpclinks/:vpclink_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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}}/vpclinks/:vpclink_id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vpclinks/:vpclink_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vpclinks/:vpclink_id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({patchOperations: [{op: '', path: '', value: '', from: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/vpclinks/:vpclink_id',
  headers: {'content-type': 'application/json'},
  body: {patchOperations: [{op: '', path: '', value: '', from: ''}]},
  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}}/vpclinks/:vpclink_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  patchOperations: [
    {
      op: '',
      path: '',
      value: '',
      from: ''
    }
  ]
});

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}}/vpclinks/:vpclink_id',
  headers: {'content-type': 'application/json'},
  data: {patchOperations: [{op: '', path: '', value: '', from: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/vpclinks/:vpclink_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"patchOperations":[{"op":"","path":"","value":"","from":""}]}'
};

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 = @{ @"patchOperations": @[ @{ @"op": @"", @"path": @"", @"value": @"", @"from": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vpclinks/:vpclink_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vpclinks/:vpclink_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/vpclinks/:vpclink_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'patchOperations' => [
        [
                'op' => '',
                'path' => '',
                'value' => '',
                'from' => ''
        ]
    ]
  ]),
  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}}/vpclinks/:vpclink_id', [
  'body' => '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/vpclinks/:vpclink_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'patchOperations' => [
    [
        'op' => '',
        'path' => '',
        'value' => '',
        'from' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/vpclinks/:vpclink_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vpclinks/:vpclink_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vpclinks/:vpclink_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/vpclinks/:vpclink_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/vpclinks/:vpclink_id"

payload = { "patchOperations": [
        {
            "op": "",
            "path": "",
            "value": "",
            "from": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/vpclinks/:vpclink_id"

payload <- "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/vpclinks/:vpclink_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/vpclinks/:vpclink_id') do |req|
  req.body = "{\n  \"patchOperations\": [\n    {\n      \"op\": \"\",\n      \"path\": \"\",\n      \"value\": \"\",\n      \"from\": \"\"\n    }\n  ]\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}}/vpclinks/:vpclink_id";

    let payload = json!({"patchOperations": (
            json!({
                "op": "",
                "path": "",
                "value": "",
                "from": ""
            })
        )});

    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}}/vpclinks/:vpclink_id \
  --header 'content-type: application/json' \
  --data '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}'

echo '{
  "patchOperations": [
    {
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/vpclinks/:vpclink_id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "patchOperations": [\n    {\n      "op": "",\n      "path": "",\n      "value": "",\n      "from": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/vpclinks/:vpclink_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["patchOperations": [
    [
      "op": "",
      "path": "",
      "value": "",
      "from": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vpclinks/:vpclink_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()