AWS Ground Station

DELETE CancelContact

{{baseUrl}}/contact/:contactId

QUERY PARAMS

contactId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contact/:contactId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/contact/:contactId")

require "http/client"

url = "{{baseUrl}}/contact/:contactId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/contact/:contactId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/contact/:contactId'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/contact/:contactId');

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}}/contact/:contactId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/contact/:contactId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact/:contactId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/contact/:contactId")

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

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

import requests

url = "{{baseUrl}}/contact/:contactId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact/:contactId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contact/:contactId")

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/contact/:contactId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/contact/:contactId

http DELETE {{baseUrl}}/contact/:contactId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/contact/:contactId

import Foundation

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

{{baseUrl}}/config

BODY json

{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": "",
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/config" {:content-type :json
                                                   :form-params {:configData {:antennaDownlinkConfig ""
                                                                              :antennaDownlinkDemodDecodeConfig ""
                                                                              :antennaUplinkConfig ""
                                                                              :dataflowEndpointConfig ""
                                                                              :s3RecordingConfig ""
                                                                              :trackingConfig ""
                                                                              :uplinkEchoConfig ""}
                                                                 :name ""
                                                                 :tags {}}})

require "http/client"

url = "{{baseUrl}}/config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\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}}/config"),
    Content = new StringContent("{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\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}}/config");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\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/config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 277

{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/config"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\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  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/config")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/config")
  .header("content-type", "application/json")
  .body("{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  configData: {
    antennaDownlinkConfig: '',
    antennaDownlinkDemodDecodeConfig: '',
    antennaUplinkConfig: '',
    dataflowEndpointConfig: '',
    s3RecordingConfig: '',
    trackingConfig: '',
    uplinkEchoConfig: ''
  },
  name: '',
  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}}/config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/config',
  headers: {'content-type': 'application/json'},
  data: {
    configData: {
      antennaDownlinkConfig: '',
      antennaDownlinkDemodDecodeConfig: '',
      antennaUplinkConfig: '',
      dataflowEndpointConfig: '',
      s3RecordingConfig: '',
      trackingConfig: '',
      uplinkEchoConfig: ''
    },
    name: '',
    tags: {}
  }
};

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

const url = '{{baseUrl}}/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"configData":{"antennaDownlinkConfig":"","antennaDownlinkDemodDecodeConfig":"","antennaUplinkConfig":"","dataflowEndpointConfig":"","s3RecordingConfig":"","trackingConfig":"","uplinkEchoConfig":""},"name":"","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}}/config',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "configData": {\n    "antennaDownlinkConfig": "",\n    "antennaDownlinkDemodDecodeConfig": "",\n    "antennaUplinkConfig": "",\n    "dataflowEndpointConfig": "",\n    "s3RecordingConfig": "",\n    "trackingConfig": "",\n    "uplinkEchoConfig": ""\n  },\n  "name": "",\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  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/config")
  .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/config',
  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({
  configData: {
    antennaDownlinkConfig: '',
    antennaDownlinkDemodDecodeConfig: '',
    antennaUplinkConfig: '',
    dataflowEndpointConfig: '',
    s3RecordingConfig: '',
    trackingConfig: '',
    uplinkEchoConfig: ''
  },
  name: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/config',
  headers: {'content-type': 'application/json'},
  body: {
    configData: {
      antennaDownlinkConfig: '',
      antennaDownlinkDemodDecodeConfig: '',
      antennaUplinkConfig: '',
      dataflowEndpointConfig: '',
      s3RecordingConfig: '',
      trackingConfig: '',
      uplinkEchoConfig: ''
    },
    name: '',
    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}}/config');

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

req.type('json');
req.send({
  configData: {
    antennaDownlinkConfig: '',
    antennaDownlinkDemodDecodeConfig: '',
    antennaUplinkConfig: '',
    dataflowEndpointConfig: '',
    s3RecordingConfig: '',
    trackingConfig: '',
    uplinkEchoConfig: ''
  },
  name: '',
  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}}/config',
  headers: {'content-type': 'application/json'},
  data: {
    configData: {
      antennaDownlinkConfig: '',
      antennaDownlinkDemodDecodeConfig: '',
      antennaUplinkConfig: '',
      dataflowEndpointConfig: '',
      s3RecordingConfig: '',
      trackingConfig: '',
      uplinkEchoConfig: ''
    },
    name: '',
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"configData":{"antennaDownlinkConfig":"","antennaDownlinkDemodDecodeConfig":"","antennaUplinkConfig":"","dataflowEndpointConfig":"","s3RecordingConfig":"","trackingConfig":"","uplinkEchoConfig":""},"name":"","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 = @{ @"configData": @{ @"antennaDownlinkConfig": @"", @"antennaDownlinkDemodDecodeConfig": @"", @"antennaUplinkConfig": @"", @"dataflowEndpointConfig": @"", @"s3RecordingConfig": @"", @"trackingConfig": @"", @"uplinkEchoConfig": @"" },
                              @"name": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/config"]
                                                       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}}/config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/config",
  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([
    'configData' => [
        'antennaDownlinkConfig' => '',
        'antennaDownlinkDemodDecodeConfig' => '',
        'antennaUplinkConfig' => '',
        'dataflowEndpointConfig' => '',
        's3RecordingConfig' => '',
        'trackingConfig' => '',
        'uplinkEchoConfig' => ''
    ],
    'name' => '',
    '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}}/config', [
  'body' => '{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'configData' => [
    'antennaDownlinkConfig' => '',
    'antennaDownlinkDemodDecodeConfig' => '',
    'antennaUplinkConfig' => '',
    'dataflowEndpointConfig' => '',
    's3RecordingConfig' => '',
    'trackingConfig' => '',
    'uplinkEchoConfig' => ''
  ],
  'name' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'configData' => [
    'antennaDownlinkConfig' => '',
    'antennaDownlinkDemodDecodeConfig' => '',
    'antennaUplinkConfig' => '',
    'dataflowEndpointConfig' => '',
    's3RecordingConfig' => '',
    'trackingConfig' => '',
    'uplinkEchoConfig' => ''
  ],
  'name' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/config');
$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}}/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/config"

payload = {
    "configData": {
        "antennaDownlinkConfig": "",
        "antennaDownlinkDemodDecodeConfig": "",
        "antennaUplinkConfig": "",
        "dataflowEndpointConfig": "",
        "s3RecordingConfig": "",
        "trackingConfig": "",
        "uplinkEchoConfig": ""
    },
    "name": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\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}}/config")

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  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\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/config') do |req|
  req.body = "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\",\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}}/config";

    let payload = json!({
        "configData": json!({
            "antennaDownlinkConfig": "",
            "antennaDownlinkDemodDecodeConfig": "",
            "antennaUplinkConfig": "",
            "dataflowEndpointConfig": "",
            "s3RecordingConfig": "",
            "trackingConfig": "",
            "uplinkEchoConfig": ""
        }),
        "name": "",
        "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}}/config \
  --header 'content-type: application/json' \
  --data '{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": "",
  "tags": {}
}'

echo '{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/config \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "configData": {\n    "antennaDownlinkConfig": "",\n    "antennaDownlinkDemodDecodeConfig": "",\n    "antennaUplinkConfig": "",\n    "dataflowEndpointConfig": "",\n    "s3RecordingConfig": "",\n    "trackingConfig": "",\n    "uplinkEchoConfig": ""\n  },\n  "name": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "configData": [
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  ],
  "name": "",
  "tags": []
] as [String : Any]

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

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

{{baseUrl}}/dataflowEndpointGroup

BODY json

{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "endpointDetails": [
    {
      "awsGroundStationAgentEndpoint": "",
      "endpoint": "",
      "healthReasons": "",
      "healthStatus": "",
      "securityDetails": ""
    }
  ],
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\n  ],\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/dataflowEndpointGroup" {:content-type :json
                                                                  :form-params {:contactPostPassDurationSeconds 0
                                                                                :contactPrePassDurationSeconds 0
                                                                                :endpointDetails [{:awsGroundStationAgentEndpoint ""
                                                                                                   :endpoint ""
                                                                                                   :healthReasons ""
                                                                                                   :healthStatus ""
                                                                                                   :securityDetails ""}]
                                                                                :tags {}}})

require "http/client"

url = "{{baseUrl}}/dataflowEndpointGroup"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\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}}/dataflowEndpointGroup"),
    Content = new StringContent("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\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}}/dataflowEndpointGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\n  ],\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\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/dataflowEndpointGroup HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 279

{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "endpointDetails": [
    {
      "awsGroundStationAgentEndpoint": "",
      "endpoint": "",
      "healthReasons": "",
      "healthStatus": "",
      "securityDetails": ""
    }
  ],
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dataflowEndpointGroup")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\n  ],\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dataflowEndpointGroup"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\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  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\n  ],\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/dataflowEndpointGroup")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/dataflowEndpointGroup")
  .header("content-type", "application/json")
  .body("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\n  ],\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  contactPostPassDurationSeconds: 0,
  contactPrePassDurationSeconds: 0,
  endpointDetails: [
    {
      awsGroundStationAgentEndpoint: '',
      endpoint: '',
      healthReasons: '',
      healthStatus: '',
      securityDetails: ''
    }
  ],
  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}}/dataflowEndpointGroup');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dataflowEndpointGroup',
  headers: {'content-type': 'application/json'},
  data: {
    contactPostPassDurationSeconds: 0,
    contactPrePassDurationSeconds: 0,
    endpointDetails: [
      {
        awsGroundStationAgentEndpoint: '',
        endpoint: '',
        healthReasons: '',
        healthStatus: '',
        securityDetails: ''
      }
    ],
    tags: {}
  }
};

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

const url = '{{baseUrl}}/dataflowEndpointGroup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contactPostPassDurationSeconds":0,"contactPrePassDurationSeconds":0,"endpointDetails":[{"awsGroundStationAgentEndpoint":"","endpoint":"","healthReasons":"","healthStatus":"","securityDetails":""}],"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}}/dataflowEndpointGroup',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "contactPostPassDurationSeconds": 0,\n  "contactPrePassDurationSeconds": 0,\n  "endpointDetails": [\n    {\n      "awsGroundStationAgentEndpoint": "",\n      "endpoint": "",\n      "healthReasons": "",\n      "healthStatus": "",\n      "securityDetails": ""\n    }\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  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\n  ],\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/dataflowEndpointGroup")
  .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/dataflowEndpointGroup',
  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({
  contactPostPassDurationSeconds: 0,
  contactPrePassDurationSeconds: 0,
  endpointDetails: [
    {
      awsGroundStationAgentEndpoint: '',
      endpoint: '',
      healthReasons: '',
      healthStatus: '',
      securityDetails: ''
    }
  ],
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dataflowEndpointGroup',
  headers: {'content-type': 'application/json'},
  body: {
    contactPostPassDurationSeconds: 0,
    contactPrePassDurationSeconds: 0,
    endpointDetails: [
      {
        awsGroundStationAgentEndpoint: '',
        endpoint: '',
        healthReasons: '',
        healthStatus: '',
        securityDetails: ''
      }
    ],
    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}}/dataflowEndpointGroup');

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

req.type('json');
req.send({
  contactPostPassDurationSeconds: 0,
  contactPrePassDurationSeconds: 0,
  endpointDetails: [
    {
      awsGroundStationAgentEndpoint: '',
      endpoint: '',
      healthReasons: '',
      healthStatus: '',
      securityDetails: ''
    }
  ],
  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}}/dataflowEndpointGroup',
  headers: {'content-type': 'application/json'},
  data: {
    contactPostPassDurationSeconds: 0,
    contactPrePassDurationSeconds: 0,
    endpointDetails: [
      {
        awsGroundStationAgentEndpoint: '',
        endpoint: '',
        healthReasons: '',
        healthStatus: '',
        securityDetails: ''
      }
    ],
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/dataflowEndpointGroup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contactPostPassDurationSeconds":0,"contactPrePassDurationSeconds":0,"endpointDetails":[{"awsGroundStationAgentEndpoint":"","endpoint":"","healthReasons":"","healthStatus":"","securityDetails":""}],"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 = @{ @"contactPostPassDurationSeconds": @0,
                              @"contactPrePassDurationSeconds": @0,
                              @"endpointDetails": @[ @{ @"awsGroundStationAgentEndpoint": @"", @"endpoint": @"", @"healthReasons": @"", @"healthStatus": @"", @"securityDetails": @"" } ],
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dataflowEndpointGroup"]
                                                       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}}/dataflowEndpointGroup" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\n  ],\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/dataflowEndpointGroup",
  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([
    'contactPostPassDurationSeconds' => 0,
    'contactPrePassDurationSeconds' => 0,
    'endpointDetails' => [
        [
                'awsGroundStationAgentEndpoint' => '',
                'endpoint' => '',
                'healthReasons' => '',
                'healthStatus' => '',
                'securityDetails' => ''
        ]
    ],
    '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}}/dataflowEndpointGroup', [
  'body' => '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "endpointDetails": [
    {
      "awsGroundStationAgentEndpoint": "",
      "endpoint": "",
      "healthReasons": "",
      "healthStatus": "",
      "securityDetails": ""
    }
  ],
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'contactPostPassDurationSeconds' => 0,
  'contactPrePassDurationSeconds' => 0,
  'endpointDetails' => [
    [
        'awsGroundStationAgentEndpoint' => '',
        'endpoint' => '',
        'healthReasons' => '',
        'healthStatus' => '',
        'securityDetails' => ''
    ]
  ],
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'contactPostPassDurationSeconds' => 0,
  'contactPrePassDurationSeconds' => 0,
  'endpointDetails' => [
    [
        'awsGroundStationAgentEndpoint' => '',
        'endpoint' => '',
        'healthReasons' => '',
        'healthStatus' => '',
        'securityDetails' => ''
    ]
  ],
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/dataflowEndpointGroup');
$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}}/dataflowEndpointGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "endpointDetails": [
    {
      "awsGroundStationAgentEndpoint": "",
      "endpoint": "",
      "healthReasons": "",
      "healthStatus": "",
      "securityDetails": ""
    }
  ],
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataflowEndpointGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "endpointDetails": [
    {
      "awsGroundStationAgentEndpoint": "",
      "endpoint": "",
      "healthReasons": "",
      "healthStatus": "",
      "securityDetails": ""
    }
  ],
  "tags": {}
}'

import http.client

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

payload = "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\n  ],\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/dataflowEndpointGroup"

payload = {
    "contactPostPassDurationSeconds": 0,
    "contactPrePassDurationSeconds": 0,
    "endpointDetails": [
        {
            "awsGroundStationAgentEndpoint": "",
            "endpoint": "",
            "healthReasons": "",
            "healthStatus": "",
            "securityDetails": ""
        }
    ],
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\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}}/dataflowEndpointGroup")

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  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\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/dataflowEndpointGroup') do |req|
  req.body = "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"endpointDetails\": [\n    {\n      \"awsGroundStationAgentEndpoint\": \"\",\n      \"endpoint\": \"\",\n      \"healthReasons\": \"\",\n      \"healthStatus\": \"\",\n      \"securityDetails\": \"\"\n    }\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}}/dataflowEndpointGroup";

    let payload = json!({
        "contactPostPassDurationSeconds": 0,
        "contactPrePassDurationSeconds": 0,
        "endpointDetails": (
            json!({
                "awsGroundStationAgentEndpoint": "",
                "endpoint": "",
                "healthReasons": "",
                "healthStatus": "",
                "securityDetails": ""
            })
        ),
        "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}}/dataflowEndpointGroup \
  --header 'content-type: application/json' \
  --data '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "endpointDetails": [
    {
      "awsGroundStationAgentEndpoint": "",
      "endpoint": "",
      "healthReasons": "",
      "healthStatus": "",
      "securityDetails": ""
    }
  ],
  "tags": {}
}'

echo '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "endpointDetails": [
    {
      "awsGroundStationAgentEndpoint": "",
      "endpoint": "",
      "healthReasons": "",
      "healthStatus": "",
      "securityDetails": ""
    }
  ],
  "tags": {}
}' |  \
  http POST {{baseUrl}}/dataflowEndpointGroup \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "contactPostPassDurationSeconds": 0,\n  "contactPrePassDurationSeconds": 0,\n  "endpointDetails": [\n    {\n      "awsGroundStationAgentEndpoint": "",\n      "endpoint": "",\n      "healthReasons": "",\n      "healthStatus": "",\n      "securityDetails": ""\n    }\n  ],\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/dataflowEndpointGroup

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "endpointDetails": [
    [
      "awsGroundStationAgentEndpoint": "",
      "endpoint": "",
      "healthReasons": "",
      "healthStatus": "",
      "securityDetails": ""
    ]
  ],
  "tags": []
] as [String : Any]

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

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

{{baseUrl}}/ephemeris

BODY json

{
  "enabled": false,
  "ephemeris": {
    "oem": {
      "oemData": "",
      "s3Object": ""
    },
    "tle": {
      "s3Object": "",
      "tleData": ""
    }
  },
  "expirationTime": "",
  "kmsKeyArn": "",
  "name": "",
  "priority": 0,
  "satelliteId": "",
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/ephemeris" {:content-type :json
                                                      :form-params {:enabled false
                                                                    :ephemeris {:oem {:oemData ""
                                                                                      :s3Object ""}
                                                                                :tle {:s3Object ""
                                                                                      :tleData ""}}
                                                                    :expirationTime ""
                                                                    :kmsKeyArn ""
                                                                    :name ""
                                                                    :priority 0
                                                                    :satelliteId ""
                                                                    :tags {}}})

require "http/client"

url = "{{baseUrl}}/ephemeris"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\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}}/ephemeris"),
    Content = new StringContent("{\n  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\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}}/ephemeris");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\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/ephemeris HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 276

{
  "enabled": false,
  "ephemeris": {
    "oem": {
      "oemData": "",
      "s3Object": ""
    },
    "tle": {
      "s3Object": "",
      "tleData": ""
    }
  },
  "expirationTime": "",
  "kmsKeyArn": "",
  "name": "",
  "priority": 0,
  "satelliteId": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/ephemeris")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ephemeris"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\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  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/ephemeris")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/ephemeris")
  .header("content-type", "application/json")
  .body("{\n  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  enabled: false,
  ephemeris: {
    oem: {
      oemData: '',
      s3Object: ''
    },
    tle: {
      s3Object: '',
      tleData: ''
    }
  },
  expirationTime: '',
  kmsKeyArn: '',
  name: '',
  priority: 0,
  satelliteId: '',
  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}}/ephemeris');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ephemeris',
  headers: {'content-type': 'application/json'},
  data: {
    enabled: false,
    ephemeris: {oem: {oemData: '', s3Object: ''}, tle: {s3Object: '', tleData: ''}},
    expirationTime: '',
    kmsKeyArn: '',
    name: '',
    priority: 0,
    satelliteId: '',
    tags: {}
  }
};

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

const url = '{{baseUrl}}/ephemeris';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"enabled":false,"ephemeris":{"oem":{"oemData":"","s3Object":""},"tle":{"s3Object":"","tleData":""}},"expirationTime":"","kmsKeyArn":"","name":"","priority":0,"satelliteId":"","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}}/ephemeris',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "enabled": false,\n  "ephemeris": {\n    "oem": {\n      "oemData": "",\n      "s3Object": ""\n    },\n    "tle": {\n      "s3Object": "",\n      "tleData": ""\n    }\n  },\n  "expirationTime": "",\n  "kmsKeyArn": "",\n  "name": "",\n  "priority": 0,\n  "satelliteId": "",\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  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/ephemeris")
  .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/ephemeris',
  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({
  enabled: false,
  ephemeris: {oem: {oemData: '', s3Object: ''}, tle: {s3Object: '', tleData: ''}},
  expirationTime: '',
  kmsKeyArn: '',
  name: '',
  priority: 0,
  satelliteId: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ephemeris',
  headers: {'content-type': 'application/json'},
  body: {
    enabled: false,
    ephemeris: {oem: {oemData: '', s3Object: ''}, tle: {s3Object: '', tleData: ''}},
    expirationTime: '',
    kmsKeyArn: '',
    name: '',
    priority: 0,
    satelliteId: '',
    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}}/ephemeris');

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

req.type('json');
req.send({
  enabled: false,
  ephemeris: {
    oem: {
      oemData: '',
      s3Object: ''
    },
    tle: {
      s3Object: '',
      tleData: ''
    }
  },
  expirationTime: '',
  kmsKeyArn: '',
  name: '',
  priority: 0,
  satelliteId: '',
  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}}/ephemeris',
  headers: {'content-type': 'application/json'},
  data: {
    enabled: false,
    ephemeris: {oem: {oemData: '', s3Object: ''}, tle: {s3Object: '', tleData: ''}},
    expirationTime: '',
    kmsKeyArn: '',
    name: '',
    priority: 0,
    satelliteId: '',
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/ephemeris';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"enabled":false,"ephemeris":{"oem":{"oemData":"","s3Object":""},"tle":{"s3Object":"","tleData":""}},"expirationTime":"","kmsKeyArn":"","name":"","priority":0,"satelliteId":"","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 = @{ @"enabled": @NO,
                              @"ephemeris": @{ @"oem": @{ @"oemData": @"", @"s3Object": @"" }, @"tle": @{ @"s3Object": @"", @"tleData": @"" } },
                              @"expirationTime": @"",
                              @"kmsKeyArn": @"",
                              @"name": @"",
                              @"priority": @0,
                              @"satelliteId": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ephemeris"]
                                                       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}}/ephemeris" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/ephemeris",
  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([
    'enabled' => null,
    'ephemeris' => [
        'oem' => [
                'oemData' => '',
                's3Object' => ''
        ],
        'tle' => [
                's3Object' => '',
                'tleData' => ''
        ]
    ],
    'expirationTime' => '',
    'kmsKeyArn' => '',
    'name' => '',
    'priority' => 0,
    'satelliteId' => '',
    '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}}/ephemeris', [
  'body' => '{
  "enabled": false,
  "ephemeris": {
    "oem": {
      "oemData": "",
      "s3Object": ""
    },
    "tle": {
      "s3Object": "",
      "tleData": ""
    }
  },
  "expirationTime": "",
  "kmsKeyArn": "",
  "name": "",
  "priority": 0,
  "satelliteId": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'enabled' => null,
  'ephemeris' => [
    'oem' => [
        'oemData' => '',
        's3Object' => ''
    ],
    'tle' => [
        's3Object' => '',
        'tleData' => ''
    ]
  ],
  'expirationTime' => '',
  'kmsKeyArn' => '',
  'name' => '',
  'priority' => 0,
  'satelliteId' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'enabled' => null,
  'ephemeris' => [
    'oem' => [
        'oemData' => '',
        's3Object' => ''
    ],
    'tle' => [
        's3Object' => '',
        'tleData' => ''
    ]
  ],
  'expirationTime' => '',
  'kmsKeyArn' => '',
  'name' => '',
  'priority' => 0,
  'satelliteId' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/ephemeris');
$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}}/ephemeris' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "enabled": false,
  "ephemeris": {
    "oem": {
      "oemData": "",
      "s3Object": ""
    },
    "tle": {
      "s3Object": "",
      "tleData": ""
    }
  },
  "expirationTime": "",
  "kmsKeyArn": "",
  "name": "",
  "priority": 0,
  "satelliteId": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ephemeris' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "enabled": false,
  "ephemeris": {
    "oem": {
      "oemData": "",
      "s3Object": ""
    },
    "tle": {
      "s3Object": "",
      "tleData": ""
    }
  },
  "expirationTime": "",
  "kmsKeyArn": "",
  "name": "",
  "priority": 0,
  "satelliteId": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/ephemeris"

payload = {
    "enabled": False,
    "ephemeris": {
        "oem": {
            "oemData": "",
            "s3Object": ""
        },
        "tle": {
            "s3Object": "",
            "tleData": ""
        }
    },
    "expirationTime": "",
    "kmsKeyArn": "",
    "name": "",
    "priority": 0,
    "satelliteId": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\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}}/ephemeris")

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  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\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/ephemeris') do |req|
  req.body = "{\n  \"enabled\": false,\n  \"ephemeris\": {\n    \"oem\": {\n      \"oemData\": \"\",\n      \"s3Object\": \"\"\n    },\n    \"tle\": {\n      \"s3Object\": \"\",\n      \"tleData\": \"\"\n    }\n  },\n  \"expirationTime\": \"\",\n  \"kmsKeyArn\": \"\",\n  \"name\": \"\",\n  \"priority\": 0,\n  \"satelliteId\": \"\",\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}}/ephemeris";

    let payload = json!({
        "enabled": false,
        "ephemeris": json!({
            "oem": json!({
                "oemData": "",
                "s3Object": ""
            }),
            "tle": json!({
                "s3Object": "",
                "tleData": ""
            })
        }),
        "expirationTime": "",
        "kmsKeyArn": "",
        "name": "",
        "priority": 0,
        "satelliteId": "",
        "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}}/ephemeris \
  --header 'content-type: application/json' \
  --data '{
  "enabled": false,
  "ephemeris": {
    "oem": {
      "oemData": "",
      "s3Object": ""
    },
    "tle": {
      "s3Object": "",
      "tleData": ""
    }
  },
  "expirationTime": "",
  "kmsKeyArn": "",
  "name": "",
  "priority": 0,
  "satelliteId": "",
  "tags": {}
}'

echo '{
  "enabled": false,
  "ephemeris": {
    "oem": {
      "oemData": "",
      "s3Object": ""
    },
    "tle": {
      "s3Object": "",
      "tleData": ""
    }
  },
  "expirationTime": "",
  "kmsKeyArn": "",
  "name": "",
  "priority": 0,
  "satelliteId": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/ephemeris \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "enabled": false,\n  "ephemeris": {\n    "oem": {\n      "oemData": "",\n      "s3Object": ""\n    },\n    "tle": {\n      "s3Object": "",\n      "tleData": ""\n    }\n  },\n  "expirationTime": "",\n  "kmsKeyArn": "",\n  "name": "",\n  "priority": 0,\n  "satelliteId": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/ephemeris

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "enabled": false,
  "ephemeris": [
    "oem": [
      "oemData": "",
      "s3Object": ""
    ],
    "tle": [
      "s3Object": "",
      "tleData": ""
    ]
  ],
  "expirationTime": "",
  "kmsKeyArn": "",
  "name": "",
  "priority": 0,
  "satelliteId": "",
  "tags": []
] as [String : Any]

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

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

{{baseUrl}}/missionprofile

BODY json

{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "tags": {},
  "trackingConfigArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/missionprofile" {:content-type :json
                                                           :form-params {:contactPostPassDurationSeconds 0
                                                                         :contactPrePassDurationSeconds 0
                                                                         :dataflowEdges []
                                                                         :minimumViableContactDurationSeconds 0
                                                                         :name ""
                                                                         :streamsKmsKey {:kmsAliasArn ""
                                                                                         :kmsKeyArn ""}
                                                                         :streamsKmsRole ""
                                                                         :tags {}
                                                                         :trackingConfigArn ""}})

require "http/client"

url = "{{baseUrl}}/missionprofile"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\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}}/missionprofile"),
    Content = new StringContent("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\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}}/missionprofile");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\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/missionprofile HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 294

{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "tags": {},
  "trackingConfigArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/missionprofile")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/missionprofile"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\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  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/missionprofile")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/missionprofile")
  .header("content-type", "application/json")
  .body("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  contactPostPassDurationSeconds: 0,
  contactPrePassDurationSeconds: 0,
  dataflowEdges: [],
  minimumViableContactDurationSeconds: 0,
  name: '',
  streamsKmsKey: {
    kmsAliasArn: '',
    kmsKeyArn: ''
  },
  streamsKmsRole: '',
  tags: {},
  trackingConfigArn: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/missionprofile',
  headers: {'content-type': 'application/json'},
  data: {
    contactPostPassDurationSeconds: 0,
    contactPrePassDurationSeconds: 0,
    dataflowEdges: [],
    minimumViableContactDurationSeconds: 0,
    name: '',
    streamsKmsKey: {kmsAliasArn: '', kmsKeyArn: ''},
    streamsKmsRole: '',
    tags: {},
    trackingConfigArn: ''
  }
};

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

const url = '{{baseUrl}}/missionprofile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contactPostPassDurationSeconds":0,"contactPrePassDurationSeconds":0,"dataflowEdges":[],"minimumViableContactDurationSeconds":0,"name":"","streamsKmsKey":{"kmsAliasArn":"","kmsKeyArn":""},"streamsKmsRole":"","tags":{},"trackingConfigArn":""}'
};

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}}/missionprofile',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "contactPostPassDurationSeconds": 0,\n  "contactPrePassDurationSeconds": 0,\n  "dataflowEdges": [],\n  "minimumViableContactDurationSeconds": 0,\n  "name": "",\n  "streamsKmsKey": {\n    "kmsAliasArn": "",\n    "kmsKeyArn": ""\n  },\n  "streamsKmsRole": "",\n  "tags": {},\n  "trackingConfigArn": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/missionprofile")
  .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/missionprofile',
  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({
  contactPostPassDurationSeconds: 0,
  contactPrePassDurationSeconds: 0,
  dataflowEdges: [],
  minimumViableContactDurationSeconds: 0,
  name: '',
  streamsKmsKey: {kmsAliasArn: '', kmsKeyArn: ''},
  streamsKmsRole: '',
  tags: {},
  trackingConfigArn: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/missionprofile',
  headers: {'content-type': 'application/json'},
  body: {
    contactPostPassDurationSeconds: 0,
    contactPrePassDurationSeconds: 0,
    dataflowEdges: [],
    minimumViableContactDurationSeconds: 0,
    name: '',
    streamsKmsKey: {kmsAliasArn: '', kmsKeyArn: ''},
    streamsKmsRole: '',
    tags: {},
    trackingConfigArn: ''
  },
  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}}/missionprofile');

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

req.type('json');
req.send({
  contactPostPassDurationSeconds: 0,
  contactPrePassDurationSeconds: 0,
  dataflowEdges: [],
  minimumViableContactDurationSeconds: 0,
  name: '',
  streamsKmsKey: {
    kmsAliasArn: '',
    kmsKeyArn: ''
  },
  streamsKmsRole: '',
  tags: {},
  trackingConfigArn: ''
});

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}}/missionprofile',
  headers: {'content-type': 'application/json'},
  data: {
    contactPostPassDurationSeconds: 0,
    contactPrePassDurationSeconds: 0,
    dataflowEdges: [],
    minimumViableContactDurationSeconds: 0,
    name: '',
    streamsKmsKey: {kmsAliasArn: '', kmsKeyArn: ''},
    streamsKmsRole: '',
    tags: {},
    trackingConfigArn: ''
  }
};

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

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

const url = '{{baseUrl}}/missionprofile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contactPostPassDurationSeconds":0,"contactPrePassDurationSeconds":0,"dataflowEdges":[],"minimumViableContactDurationSeconds":0,"name":"","streamsKmsKey":{"kmsAliasArn":"","kmsKeyArn":""},"streamsKmsRole":"","tags":{},"trackingConfigArn":""}'
};

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 = @{ @"contactPostPassDurationSeconds": @0,
                              @"contactPrePassDurationSeconds": @0,
                              @"dataflowEdges": @[  ],
                              @"minimumViableContactDurationSeconds": @0,
                              @"name": @"",
                              @"streamsKmsKey": @{ @"kmsAliasArn": @"", @"kmsKeyArn": @"" },
                              @"streamsKmsRole": @"",
                              @"tags": @{  },
                              @"trackingConfigArn": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/missionprofile"]
                                                       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}}/missionprofile" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\n}" in

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

 "{{baseUrl}}/missionprofile",
  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([
    'contactPostPassDurationSeconds' => 0,
    'contactPrePassDurationSeconds' => 0,
    'dataflowEdges' => [
        
    ],
    'minimumViableContactDurationSeconds' => 0,
    'name' => '',
    'streamsKmsKey' => [
        'kmsAliasArn' => '',
        'kmsKeyArn' => ''
    ],
    'streamsKmsRole' => '',
    'tags' => [
        
    ],
    'trackingConfigArn' => ''
  ]),
  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}}/missionprofile', [
  'body' => '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "tags": {},
  "trackingConfigArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'contactPostPassDurationSeconds' => 0,
  'contactPrePassDurationSeconds' => 0,
  'dataflowEdges' => [
    
  ],
  'minimumViableContactDurationSeconds' => 0,
  'name' => '',
  'streamsKmsKey' => [
    'kmsAliasArn' => '',
    'kmsKeyArn' => ''
  ],
  'streamsKmsRole' => '',
  'tags' => [
    
  ],
  'trackingConfigArn' => ''
]));

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

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

append(json_encode([
  'contactPostPassDurationSeconds' => 0,
  'contactPrePassDurationSeconds' => 0,
  'dataflowEdges' => [
    
  ],
  'minimumViableContactDurationSeconds' => 0,
  'name' => '',
  'streamsKmsKey' => [
    'kmsAliasArn' => '',
    'kmsKeyArn' => ''
  ],
  'streamsKmsRole' => '',
  'tags' => [
    
  ],
  'trackingConfigArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/missionprofile');
$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}}/missionprofile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "tags": {},
  "trackingConfigArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/missionprofile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "tags": {},
  "trackingConfigArn": ""
}'

import http.client

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

payload = "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/missionprofile"

payload = {
    "contactPostPassDurationSeconds": 0,
    "contactPrePassDurationSeconds": 0,
    "dataflowEdges": [],
    "minimumViableContactDurationSeconds": 0,
    "name": "",
    "streamsKmsKey": {
        "kmsAliasArn": "",
        "kmsKeyArn": ""
    },
    "streamsKmsRole": "",
    "tags": {},
    "trackingConfigArn": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\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}}/missionprofile")

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  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\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/missionprofile') do |req|
  req.body = "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"tags\": {},\n  \"trackingConfigArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "contactPostPassDurationSeconds": 0,
        "contactPrePassDurationSeconds": 0,
        "dataflowEdges": (),
        "minimumViableContactDurationSeconds": 0,
        "name": "",
        "streamsKmsKey": json!({
            "kmsAliasArn": "",
            "kmsKeyArn": ""
        }),
        "streamsKmsRole": "",
        "tags": json!({}),
        "trackingConfigArn": ""
    });

    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}}/missionprofile \
  --header 'content-type: application/json' \
  --data '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "tags": {},
  "trackingConfigArn": ""
}'

echo '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "tags": {},
  "trackingConfigArn": ""
}' |  \
  http POST {{baseUrl}}/missionprofile \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "contactPostPassDurationSeconds": 0,\n  "contactPrePassDurationSeconds": 0,\n  "dataflowEdges": [],\n  "minimumViableContactDurationSeconds": 0,\n  "name": "",\n  "streamsKmsKey": {\n    "kmsAliasArn": "",\n    "kmsKeyArn": ""\n  },\n  "streamsKmsRole": "",\n  "tags": {},\n  "trackingConfigArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/missionprofile

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": [
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  ],
  "streamsKmsRole": "",
  "tags": [],
  "trackingConfigArn": ""
] as [String : Any]

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

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

{{baseUrl}}/config/:configType/:configId

QUERY PARAMS

configId

configType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/config/:configType/:configId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/config/:configType/:configId")

require "http/client"

url = "{{baseUrl}}/config/:configType/:configId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/config/:configType/:configId"

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

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

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/config/:configType/:configId")
  .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}}/config/:configType/:configId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/config/:configType/:configId'
};

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

const url = '{{baseUrl}}/config/:configType/:configId';
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}}/config/:configType/:configId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/config/:configType/:configId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/config/:configType/:configId');

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}}/config/:configType/:configId'
};

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

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

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

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

 "{{baseUrl}}/config/:configType/:configId",
  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}}/config/:configType/:configId');

echo $response->getBody();

setUrl('{{baseUrl}}/config/:configType/:configId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/config/:configType/:configId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/config/:configType/:configId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/config/:configType/:configId")

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

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

import requests

url = "{{baseUrl}}/config/:configType/:configId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/config/:configType/:configId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/config/:configType/:configId")

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/config/:configType/:configId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/config/:configType/:configId

http DELETE {{baseUrl}}/config/:configType/:configId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/config/:configType/:configId

import Foundation

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

{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId

QUERY PARAMS

dataflowEndpointGroupId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId")

require "http/client"

url = "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId'
};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId');

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}}/dataflowEndpointGroup/:dataflowEndpointGroupId'
};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/dataflowEndpointGroup/:dataflowEndpointGroupId")

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

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

import requests

url = "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId")

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/dataflowEndpointGroup/:dataflowEndpointGroupId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/dataflowEndpointGroup/:dataflowEndpointGroupId

http DELETE {{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId

import Foundation

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

{{baseUrl}}/ephemeris/:ephemerisId

QUERY PARAMS

ephemerisId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ephemeris/:ephemerisId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/ephemeris/:ephemerisId")

require "http/client"

url = "{{baseUrl}}/ephemeris/:ephemerisId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/ephemeris/:ephemerisId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/ephemeris/:ephemerisId'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/ephemeris/:ephemerisId');

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}}/ephemeris/:ephemerisId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ephemeris/:ephemerisId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ephemeris/:ephemerisId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/ephemeris/:ephemerisId")

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

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

import requests

url = "{{baseUrl}}/ephemeris/:ephemerisId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ephemeris/:ephemerisId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ephemeris/:ephemerisId")

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/ephemeris/:ephemerisId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/ephemeris/:ephemerisId

http DELETE {{baseUrl}}/ephemeris/:ephemerisId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/ephemeris/:ephemerisId

import Foundation

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

{{baseUrl}}/missionprofile/:missionProfileId

QUERY PARAMS

missionProfileId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/missionprofile/:missionProfileId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/missionprofile/:missionProfileId")

require "http/client"

url = "{{baseUrl}}/missionprofile/:missionProfileId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/missionprofile/:missionProfileId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/missionprofile/:missionProfileId'
};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/missionprofile/:missionProfileId');

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}}/missionprofile/:missionProfileId'
};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/missionprofile/:missionProfileId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/missionprofile/:missionProfileId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/missionprofile/:missionProfileId")

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

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

import requests

url = "{{baseUrl}}/missionprofile/:missionProfileId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/missionprofile/:missionProfileId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/missionprofile/:missionProfileId")

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/missionprofile/:missionProfileId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/missionprofile/:missionProfileId

http DELETE {{baseUrl}}/missionprofile/:missionProfileId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/missionprofile/:missionProfileId

import Foundation

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

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

dataTask.resume()

GET DescribeContact

{{baseUrl}}/contact/:contactId

QUERY PARAMS

contactId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contact/:contactId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/contact/:contactId")

require "http/client"

url = "{{baseUrl}}/contact/:contactId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/contact/:contactId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/contact/:contactId');

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}}/contact/:contactId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/contact/:contactId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact/:contactId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/contact/:contactId")

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

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

import requests

url = "{{baseUrl}}/contact/:contactId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact/:contactId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/contact/:contactId")

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/contact/:contactId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/contact/:contactId

http GET {{baseUrl}}/contact/:contactId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/contact/:contactId

import Foundation

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

{{baseUrl}}/ephemeris/:ephemerisId

QUERY PARAMS

ephemerisId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ephemeris/:ephemerisId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/ephemeris/:ephemerisId")

require "http/client"

url = "{{baseUrl}}/ephemeris/:ephemerisId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/ephemeris/:ephemerisId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ephemeris/:ephemerisId');

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}}/ephemeris/:ephemerisId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ephemeris/:ephemerisId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ephemeris/:ephemerisId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/ephemeris/:ephemerisId")

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

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

import requests

url = "{{baseUrl}}/ephemeris/:ephemerisId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ephemeris/:ephemerisId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ephemeris/:ephemerisId")

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/ephemeris/:ephemerisId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/ephemeris/:ephemerisId

http GET {{baseUrl}}/ephemeris/:ephemerisId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ephemeris/:ephemerisId

import Foundation

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

{{baseUrl}}/agent/:agentId/configuration

QUERY PARAMS

agentId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/agent/:agentId/configuration");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/agent/:agentId/configuration")

require "http/client"

url = "{{baseUrl}}/agent/:agentId/configuration"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/agent/:agentId/configuration"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/agent/:agentId/configuration'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/agent/:agentId/configuration")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/agent/:agentId/configuration');

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}}/agent/:agentId/configuration'};

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

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

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

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

 "{{baseUrl}}/agent/:agentId/configuration",
  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}}/agent/:agentId/configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/agent/:agentId/configuration');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/agent/:agentId/configuration' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/agent/:agentId/configuration' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/agent/:agentId/configuration")

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

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

import requests

url = "{{baseUrl}}/agent/:agentId/configuration"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/agent/:agentId/configuration"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/agent/:agentId/configuration")

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/agent/:agentId/configuration') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/agent/:agentId/configuration

http GET {{baseUrl}}/agent/:agentId/configuration

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/agent/:agentId/configuration

import Foundation

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

{{baseUrl}}/config/:configType/:configId

QUERY PARAMS

configId

configType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/config/:configType/:configId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/config/:configType/:configId")

require "http/client"

url = "{{baseUrl}}/config/:configType/:configId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/config/:configType/:configId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/config/:configType/:configId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/config/:configType/:configId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/config/:configType/:configId');

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}}/config/:configType/:configId'};

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

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

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

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

 "{{baseUrl}}/config/:configType/:configId",
  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}}/config/:configType/:configId');

echo $response->getBody();

setUrl('{{baseUrl}}/config/:configType/:configId');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/config/:configType/:configId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/config/:configType/:configId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/config/:configType/:configId")

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

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

import requests

url = "{{baseUrl}}/config/:configType/:configId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/config/:configType/:configId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/config/:configType/:configId")

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/config/:configType/:configId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/config/:configType/:configId

http GET {{baseUrl}}/config/:configType/:configId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/config/:configType/:configId

import Foundation

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

{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId

QUERY PARAMS

dataflowEndpointGroupId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId")

require "http/client"

url = "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId');

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}}/dataflowEndpointGroup/:dataflowEndpointGroupId'
};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/dataflowEndpointGroup/:dataflowEndpointGroupId")

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

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

import requests

url = "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId")

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/dataflowEndpointGroup/:dataflowEndpointGroupId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/dataflowEndpointGroup/:dataflowEndpointGroupId

http GET {{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dataflowEndpointGroup/:dataflowEndpointGroupId

import Foundation

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

{{baseUrl}}/minute-usage

BODY json

{
  "month": 0,
  "year": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/minute-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  \"month\": 0,\n  \"year\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/minute-usage" {:content-type :json
                                                         :form-params {:month 0
                                                                       :year 0}})

require "http/client"

url = "{{baseUrl}}/minute-usage"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"month\": 0,\n  \"year\": 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}}/minute-usage"),
    Content = new StringContent("{\n  \"month\": 0,\n  \"year\": 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}}/minute-usage");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"month\": 0,\n  \"year\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/minute-usage"

	payload := strings.NewReader("{\n  \"month\": 0,\n  \"year\": 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/minute-usage HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 29

{
  "month": 0,
  "year": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/minute-usage")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"month\": 0,\n  \"year\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/minute-usage")
  .header("content-type", "application/json")
  .body("{\n  \"month\": 0,\n  \"year\": 0\n}")
  .asString();

const data = JSON.stringify({
  month: 0,
  year: 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}}/minute-usage');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/minute-usage',
  headers: {'content-type': 'application/json'},
  data: {month: 0, year: 0}
};

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

const url = '{{baseUrl}}/minute-usage';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"month":0,"year":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}}/minute-usage',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "month": 0,\n  "year": 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  \"month\": 0,\n  \"year\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/minute-usage")
  .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/minute-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({month: 0, year: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/minute-usage',
  headers: {'content-type': 'application/json'},
  body: {month: 0, year: 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}}/minute-usage');

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

req.type('json');
req.send({
  month: 0,
  year: 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}}/minute-usage',
  headers: {'content-type': 'application/json'},
  data: {month: 0, year: 0}
};

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

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

const url = '{{baseUrl}}/minute-usage';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"month":0,"year":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 = @{ @"month": @0,
                              @"year": @0 };

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

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

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

 "{{baseUrl}}/minute-usage",
  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([
    'month' => 0,
    'year' => 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}}/minute-usage', [
  'body' => '{
  "month": 0,
  "year": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'month' => 0,
  'year' => 0
]));

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

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

append(json_encode([
  'month' => 0,
  'year' => 0
]));
$request->setRequestUrl('{{baseUrl}}/minute-usage');
$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}}/minute-usage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "month": 0,
  "year": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/minute-usage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "month": 0,
  "year": 0
}'

import http.client

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

payload = "{\n  \"month\": 0,\n  \"year\": 0\n}"

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

conn.request("POST", "/baseUrl/minute-usage", payload, headers)

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

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

import requests

url = "{{baseUrl}}/minute-usage"

payload = {
    "month": 0,
    "year": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/minute-usage"

payload <- "{\n  \"month\": 0,\n  \"year\": 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}}/minute-usage")

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  \"month\": 0,\n  \"year\": 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/minute-usage') do |req|
  req.body = "{\n  \"month\": 0,\n  \"year\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "month": 0,
        "year": 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}}/minute-usage \
  --header 'content-type: application/json' \
  --data '{
  "month": 0,
  "year": 0
}'

echo '{
  "month": 0,
  "year": 0
}' |  \
  http POST {{baseUrl}}/minute-usage \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "month": 0,\n  "year": 0\n}' \
  --output-document \
  - {{baseUrl}}/minute-usage

import Foundation

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

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

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

{{baseUrl}}/missionprofile/:missionProfileId

QUERY PARAMS

missionProfileId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/missionprofile/:missionProfileId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/missionprofile/:missionProfileId")

require "http/client"

url = "{{baseUrl}}/missionprofile/:missionProfileId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/missionprofile/:missionProfileId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/missionprofile/:missionProfileId');

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}}/missionprofile/:missionProfileId'
};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/missionprofile/:missionProfileId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/missionprofile/:missionProfileId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/missionprofile/:missionProfileId")

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

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

import requests

url = "{{baseUrl}}/missionprofile/:missionProfileId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/missionprofile/:missionProfileId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/missionprofile/:missionProfileId")

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/missionprofile/:missionProfileId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/missionprofile/:missionProfileId

http GET {{baseUrl}}/missionprofile/:missionProfileId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/missionprofile/:missionProfileId

import Foundation

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

{{baseUrl}}/satellite/:satelliteId

QUERY PARAMS

satelliteId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/satellite/:satelliteId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/satellite/:satelliteId")

require "http/client"

url = "{{baseUrl}}/satellite/:satelliteId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/satellite/:satelliteId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/satellite/:satelliteId');

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}}/satellite/:satelliteId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/satellite/:satelliteId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/satellite/:satelliteId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/satellite/:satelliteId")

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

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

import requests

url = "{{baseUrl}}/satellite/:satelliteId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/satellite/:satelliteId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/satellite/:satelliteId")

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/satellite/:satelliteId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/satellite/:satelliteId

http GET {{baseUrl}}/satellite/:satelliteId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/satellite/:satelliteId

import Foundation

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

{{baseUrl}}/config

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/config"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/config"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

http GET {{baseUrl}}/config

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

import Foundation

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

{{baseUrl}}/contacts

BODY json

{
  "endTime": "",
  "groundStation": "",
  "maxResults": 0,
  "missionProfileArn": "",
  "nextToken": "",
  "satelliteArn": "",
  "startTime": "",
  "statusList": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/contacts" {:content-type :json
                                                     :form-params {:endTime ""
                                                                   :groundStation ""
                                                                   :maxResults 0
                                                                   :missionProfileArn ""
                                                                   :nextToken ""
                                                                   :satelliteArn ""
                                                                   :startTime ""
                                                                   :statusList []}})

require "http/client"

url = "{{baseUrl}}/contacts"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/contacts"),
    Content = new StringContent("{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/contacts");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}")

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

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

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

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

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

}

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

{
  "endTime": "",
  "groundStation": "",
  "maxResults": 0,
  "missionProfileArn": "",
  "nextToken": "",
  "satelliteArn": "",
  "startTime": "",
  "statusList": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contacts")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contacts"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\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  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contacts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/contacts")
  .header("content-type", "application/json")
  .body("{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}")
  .asString();

const data = JSON.stringify({
  endTime: '',
  groundStation: '',
  maxResults: 0,
  missionProfileArn: '',
  nextToken: '',
  satelliteArn: '',
  startTime: '',
  statusList: []
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contacts',
  headers: {'content-type': 'application/json'},
  data: {
    endTime: '',
    groundStation: '',
    maxResults: 0,
    missionProfileArn: '',
    nextToken: '',
    satelliteArn: '',
    startTime: '',
    statusList: []
  }
};

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

const url = '{{baseUrl}}/contacts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"endTime":"","groundStation":"","maxResults":0,"missionProfileArn":"","nextToken":"","satelliteArn":"","startTime":"","statusList":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/contacts',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "endTime": "",\n  "groundStation": "",\n  "maxResults": 0,\n  "missionProfileArn": "",\n  "nextToken": "",\n  "satelliteArn": "",\n  "startTime": "",\n  "statusList": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contacts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  endTime: '',
  groundStation: '',
  maxResults: 0,
  missionProfileArn: '',
  nextToken: '',
  satelliteArn: '',
  startTime: '',
  statusList: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contacts',
  headers: {'content-type': 'application/json'},
  body: {
    endTime: '',
    groundStation: '',
    maxResults: 0,
    missionProfileArn: '',
    nextToken: '',
    satelliteArn: '',
    startTime: '',
    statusList: []
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  endTime: '',
  groundStation: '',
  maxResults: 0,
  missionProfileArn: '',
  nextToken: '',
  satelliteArn: '',
  startTime: '',
  statusList: []
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contacts',
  headers: {'content-type': 'application/json'},
  data: {
    endTime: '',
    groundStation: '',
    maxResults: 0,
    missionProfileArn: '',
    nextToken: '',
    satelliteArn: '',
    startTime: '',
    statusList: []
  }
};

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

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

const url = '{{baseUrl}}/contacts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"endTime":"","groundStation":"","maxResults":0,"missionProfileArn":"","nextToken":"","satelliteArn":"","startTime":"","statusList":[]}'
};

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 = @{ @"endTime": @"",
                              @"groundStation": @"",
                              @"maxResults": @0,
                              @"missionProfileArn": @"",
                              @"nextToken": @"",
                              @"satelliteArn": @"",
                              @"startTime": @"",
                              @"statusList": @[  ] };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/contacts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}" in

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

 "{{baseUrl}}/contacts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'endTime' => '',
    'groundStation' => '',
    'maxResults' => 0,
    'missionProfileArn' => '',
    'nextToken' => '',
    'satelliteArn' => '',
    'startTime' => '',
    'statusList' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/contacts', [
  'body' => '{
  "endTime": "",
  "groundStation": "",
  "maxResults": 0,
  "missionProfileArn": "",
  "nextToken": "",
  "satelliteArn": "",
  "startTime": "",
  "statusList": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'endTime' => '',
  'groundStation' => '',
  'maxResults' => 0,
  'missionProfileArn' => '',
  'nextToken' => '',
  'satelliteArn' => '',
  'startTime' => '',
  'statusList' => [
    
  ]
]));

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

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

append(json_encode([
  'endTime' => '',
  'groundStation' => '',
  'maxResults' => 0,
  'missionProfileArn' => '',
  'nextToken' => '',
  'satelliteArn' => '',
  'startTime' => '',
  'statusList' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/contacts');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/contacts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "endTime": "",
  "groundStation": "",
  "maxResults": 0,
  "missionProfileArn": "",
  "nextToken": "",
  "satelliteArn": "",
  "startTime": "",
  "statusList": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contacts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "endTime": "",
  "groundStation": "",
  "maxResults": 0,
  "missionProfileArn": "",
  "nextToken": "",
  "satelliteArn": "",
  "startTime": "",
  "statusList": []
}'

import http.client

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

payload = "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/contacts"

payload = {
    "endTime": "",
    "groundStation": "",
    "maxResults": 0,
    "missionProfileArn": "",
    "nextToken": "",
    "satelliteArn": "",
    "startTime": "",
    "statusList": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/contacts') do |req|
  req.body = "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"maxResults\": 0,\n  \"missionProfileArn\": \"\",\n  \"nextToken\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "endTime": "",
        "groundStation": "",
        "maxResults": 0,
        "missionProfileArn": "",
        "nextToken": "",
        "satelliteArn": "",
        "startTime": "",
        "statusList": ()
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/contacts \
  --header 'content-type: application/json' \
  --data '{
  "endTime": "",
  "groundStation": "",
  "maxResults": 0,
  "missionProfileArn": "",
  "nextToken": "",
  "satelliteArn": "",
  "startTime": "",
  "statusList": []
}'

echo '{
  "endTime": "",
  "groundStation": "",
  "maxResults": 0,
  "missionProfileArn": "",
  "nextToken": "",
  "satelliteArn": "",
  "startTime": "",
  "statusList": []
}' |  \
  http POST {{baseUrl}}/contacts \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "endTime": "",\n  "groundStation": "",\n  "maxResults": 0,\n  "missionProfileArn": "",\n  "nextToken": "",\n  "satelliteArn": "",\n  "startTime": "",\n  "statusList": []\n}' \
  --output-document \
  - {{baseUrl}}/contacts

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "endTime": "",
  "groundStation": "",
  "maxResults": 0,
  "missionProfileArn": "",
  "nextToken": "",
  "satelliteArn": "",
  "startTime": "",
  "statusList": []
] as [String : Any]

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

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

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

dataTask.resume()

GET ListDataflowEndpointGroups

{{baseUrl}}/dataflowEndpointGroup

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/dataflowEndpointGroup"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/dataflowEndpointGroup"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

http GET {{baseUrl}}/dataflowEndpointGroup

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

import Foundation

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

{{baseUrl}}/ephemerides

BODY json

{
  "endTime": "",
  "satelliteId": "",
  "startTime": "",
  "statusList": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/ephemerides" {:content-type :json
                                                        :form-params {:endTime ""
                                                                      :satelliteId ""
                                                                      :startTime ""
                                                                      :statusList []}})

require "http/client"

url = "{{baseUrl}}/ephemerides"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\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}}/ephemerides"),
    Content = new StringContent("{\n  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\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}}/ephemerides");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\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/ephemerides HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 79

{
  "endTime": "",
  "satelliteId": "",
  "startTime": "",
  "statusList": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/ephemerides")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ephemerides"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\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  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/ephemerides")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/ephemerides")
  .header("content-type", "application/json")
  .body("{\n  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}")
  .asString();

const data = JSON.stringify({
  endTime: '',
  satelliteId: '',
  startTime: '',
  statusList: []
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ephemerides',
  headers: {'content-type': 'application/json'},
  data: {endTime: '', satelliteId: '', startTime: '', statusList: []}
};

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

const url = '{{baseUrl}}/ephemerides';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"endTime":"","satelliteId":"","startTime":"","statusList":[]}'
};

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}}/ephemerides',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "endTime": "",\n  "satelliteId": "",\n  "startTime": "",\n  "statusList": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/ephemerides")
  .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/ephemerides',
  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({endTime: '', satelliteId: '', startTime: '', statusList: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ephemerides',
  headers: {'content-type': 'application/json'},
  body: {endTime: '', satelliteId: '', startTime: '', statusList: []},
  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}}/ephemerides');

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

req.type('json');
req.send({
  endTime: '',
  satelliteId: '',
  startTime: '',
  statusList: []
});

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}}/ephemerides',
  headers: {'content-type': 'application/json'},
  data: {endTime: '', satelliteId: '', startTime: '', statusList: []}
};

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

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

const url = '{{baseUrl}}/ephemerides';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"endTime":"","satelliteId":"","startTime":"","statusList":[]}'
};

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 = @{ @"endTime": @"",
                              @"satelliteId": @"",
                              @"startTime": @"",
                              @"statusList": @[  ] };

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

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

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

 "{{baseUrl}}/ephemerides",
  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([
    'endTime' => '',
    'satelliteId' => '',
    'startTime' => '',
    'statusList' => [
        
    ]
  ]),
  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}}/ephemerides', [
  'body' => '{
  "endTime": "",
  "satelliteId": "",
  "startTime": "",
  "statusList": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'endTime' => '',
  'satelliteId' => '',
  'startTime' => '',
  'statusList' => [
    
  ]
]));

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

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

append(json_encode([
  'endTime' => '',
  'satelliteId' => '',
  'startTime' => '',
  'statusList' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/ephemerides');
$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}}/ephemerides' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "endTime": "",
  "satelliteId": "",
  "startTime": "",
  "statusList": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ephemerides' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "endTime": "",
  "satelliteId": "",
  "startTime": "",
  "statusList": []
}'

import http.client

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

payload = "{\n  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/ephemerides"

payload = {
    "endTime": "",
    "satelliteId": "",
    "startTime": "",
    "statusList": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\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}}/ephemerides")

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  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\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/ephemerides') do |req|
  req.body = "{\n  \"endTime\": \"\",\n  \"satelliteId\": \"\",\n  \"startTime\": \"\",\n  \"statusList\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "endTime": "",
        "satelliteId": "",
        "startTime": "",
        "statusList": ()
    });

    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}}/ephemerides \
  --header 'content-type: application/json' \
  --data '{
  "endTime": "",
  "satelliteId": "",
  "startTime": "",
  "statusList": []
}'

echo '{
  "endTime": "",
  "satelliteId": "",
  "startTime": "",
  "statusList": []
}' |  \
  http POST {{baseUrl}}/ephemerides \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "endTime": "",\n  "satelliteId": "",\n  "startTime": "",\n  "statusList": []\n}' \
  --output-document \
  - {{baseUrl}}/ephemerides

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "endTime": "",
  "satelliteId": "",
  "startTime": "",
  "statusList": []
] as [String : Any]

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

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

{{baseUrl}}/groundstation

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/groundstation"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/groundstation"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

http GET {{baseUrl}}/groundstation

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

import Foundation

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

{{baseUrl}}/missionprofile

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/missionprofile"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/missionprofile"

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

use reqwest;

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

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

http GET {{baseUrl}}/missionprofile

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

import Foundation

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

{{baseUrl}}/satellite

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/satellite"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/satellite');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/satellite' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/satellite' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/satellite")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/satellite"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/satellite"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/satellite")

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/satellite') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/satellite";

    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}}/satellite

http GET {{baseUrl}}/satellite

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/satellite

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/satellite")! 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 ListTagsForResource

{{baseUrl}}/tags/:resourceArn

QUERY PARAMS

resourceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tags/:resourceArn")

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"

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/:resourceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn"

	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/:resourceArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tags/:resourceArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn"))
    .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/:resourceArn")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tags/:resourceArn")
  .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/:resourceArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn';
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/:resourceArn',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn',
  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/:resourceArn'};

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/:resourceArn');

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/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn';
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/:resourceArn"]
                                                       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/:resourceArn" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn",
  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/:resourceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags/:resourceArn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/tags/:resourceArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn")

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/:resourceArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resourceArn";

    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/:resourceArn

http GET {{baseUrl}}/tags/:resourceArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn")! 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 RegisterAgent

{{baseUrl}}/agent

BODY json

{
  "agentDetails": {
    "agentCpuCores": "",
    "agentVersion": "",
    "componentVersions": "",
    "instanceId": "",
    "instanceType": "",
    "reservedCpuCores": ""
  },
  "discoveryData": {
    "capabilityArns": "",
    "privateIpAddresses": "",
    "publicIpAddresses": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/agent");

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  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/agent" {:content-type :json
                                                  :form-params {:agentDetails {:agentCpuCores ""
                                                                               :agentVersion ""
                                                                               :componentVersions ""
                                                                               :instanceId ""
                                                                               :instanceType ""
                                                                               :reservedCpuCores ""}
                                                                :discoveryData {:capabilityArns ""
                                                                                :privateIpAddresses ""
                                                                                :publicIpAddresses ""}}})

require "http/client"

url = "{{baseUrl}}/agent"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/agent"),
    Content = new StringContent("{\n  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\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}}/agent");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/agent"

	payload := strings.NewReader("{\n  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/agent HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 288

{
  "agentDetails": {
    "agentCpuCores": "",
    "agentVersion": "",
    "componentVersions": "",
    "instanceId": "",
    "instanceType": "",
    "reservedCpuCores": ""
  },
  "discoveryData": {
    "capabilityArns": "",
    "privateIpAddresses": "",
    "publicIpAddresses": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/agent")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/agent"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\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  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/agent")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/agent")
  .header("content-type", "application/json")
  .body("{\n  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  agentDetails: {
    agentCpuCores: '',
    agentVersion: '',
    componentVersions: '',
    instanceId: '',
    instanceType: '',
    reservedCpuCores: ''
  },
  discoveryData: {
    capabilityArns: '',
    privateIpAddresses: '',
    publicIpAddresses: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/agent');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/agent',
  headers: {'content-type': 'application/json'},
  data: {
    agentDetails: {
      agentCpuCores: '',
      agentVersion: '',
      componentVersions: '',
      instanceId: '',
      instanceType: '',
      reservedCpuCores: ''
    },
    discoveryData: {capabilityArns: '', privateIpAddresses: '', publicIpAddresses: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/agent';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"agentDetails":{"agentCpuCores":"","agentVersion":"","componentVersions":"","instanceId":"","instanceType":"","reservedCpuCores":""},"discoveryData":{"capabilityArns":"","privateIpAddresses":"","publicIpAddresses":""}}'
};

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}}/agent',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "agentDetails": {\n    "agentCpuCores": "",\n    "agentVersion": "",\n    "componentVersions": "",\n    "instanceId": "",\n    "instanceType": "",\n    "reservedCpuCores": ""\n  },\n  "discoveryData": {\n    "capabilityArns": "",\n    "privateIpAddresses": "",\n    "publicIpAddresses": ""\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  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/agent")
  .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/agent',
  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({
  agentDetails: {
    agentCpuCores: '',
    agentVersion: '',
    componentVersions: '',
    instanceId: '',
    instanceType: '',
    reservedCpuCores: ''
  },
  discoveryData: {capabilityArns: '', privateIpAddresses: '', publicIpAddresses: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/agent',
  headers: {'content-type': 'application/json'},
  body: {
    agentDetails: {
      agentCpuCores: '',
      agentVersion: '',
      componentVersions: '',
      instanceId: '',
      instanceType: '',
      reservedCpuCores: ''
    },
    discoveryData: {capabilityArns: '', privateIpAddresses: '', publicIpAddresses: ''}
  },
  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}}/agent');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  agentDetails: {
    agentCpuCores: '',
    agentVersion: '',
    componentVersions: '',
    instanceId: '',
    instanceType: '',
    reservedCpuCores: ''
  },
  discoveryData: {
    capabilityArns: '',
    privateIpAddresses: '',
    publicIpAddresses: ''
  }
});

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}}/agent',
  headers: {'content-type': 'application/json'},
  data: {
    agentDetails: {
      agentCpuCores: '',
      agentVersion: '',
      componentVersions: '',
      instanceId: '',
      instanceType: '',
      reservedCpuCores: ''
    },
    discoveryData: {capabilityArns: '', privateIpAddresses: '', publicIpAddresses: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/agent';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"agentDetails":{"agentCpuCores":"","agentVersion":"","componentVersions":"","instanceId":"","instanceType":"","reservedCpuCores":""},"discoveryData":{"capabilityArns":"","privateIpAddresses":"","publicIpAddresses":""}}'
};

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 = @{ @"agentDetails": @{ @"agentCpuCores": @"", @"agentVersion": @"", @"componentVersions": @"", @"instanceId": @"", @"instanceType": @"", @"reservedCpuCores": @"" },
                              @"discoveryData": @{ @"capabilityArns": @"", @"privateIpAddresses": @"", @"publicIpAddresses": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/agent"]
                                                       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}}/agent" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/agent",
  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([
    'agentDetails' => [
        'agentCpuCores' => '',
        'agentVersion' => '',
        'componentVersions' => '',
        'instanceId' => '',
        'instanceType' => '',
        'reservedCpuCores' => ''
    ],
    'discoveryData' => [
        'capabilityArns' => '',
        'privateIpAddresses' => '',
        'publicIpAddresses' => ''
    ]
  ]),
  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}}/agent', [
  'body' => '{
  "agentDetails": {
    "agentCpuCores": "",
    "agentVersion": "",
    "componentVersions": "",
    "instanceId": "",
    "instanceType": "",
    "reservedCpuCores": ""
  },
  "discoveryData": {
    "capabilityArns": "",
    "privateIpAddresses": "",
    "publicIpAddresses": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/agent');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'agentDetails' => [
    'agentCpuCores' => '',
    'agentVersion' => '',
    'componentVersions' => '',
    'instanceId' => '',
    'instanceType' => '',
    'reservedCpuCores' => ''
  ],
  'discoveryData' => [
    'capabilityArns' => '',
    'privateIpAddresses' => '',
    'publicIpAddresses' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'agentDetails' => [
    'agentCpuCores' => '',
    'agentVersion' => '',
    'componentVersions' => '',
    'instanceId' => '',
    'instanceType' => '',
    'reservedCpuCores' => ''
  ],
  'discoveryData' => [
    'capabilityArns' => '',
    'privateIpAddresses' => '',
    'publicIpAddresses' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/agent');
$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}}/agent' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "agentDetails": {
    "agentCpuCores": "",
    "agentVersion": "",
    "componentVersions": "",
    "instanceId": "",
    "instanceType": "",
    "reservedCpuCores": ""
  },
  "discoveryData": {
    "capabilityArns": "",
    "privateIpAddresses": "",
    "publicIpAddresses": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/agent' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "agentDetails": {
    "agentCpuCores": "",
    "agentVersion": "",
    "componentVersions": "",
    "instanceId": "",
    "instanceType": "",
    "reservedCpuCores": ""
  },
  "discoveryData": {
    "capabilityArns": "",
    "privateIpAddresses": "",
    "publicIpAddresses": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/agent", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/agent"

payload = {
    "agentDetails": {
        "agentCpuCores": "",
        "agentVersion": "",
        "componentVersions": "",
        "instanceId": "",
        "instanceType": "",
        "reservedCpuCores": ""
    },
    "discoveryData": {
        "capabilityArns": "",
        "privateIpAddresses": "",
        "publicIpAddresses": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/agent"

payload <- "{\n  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/agent")

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  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/agent') do |req|
  req.body = "{\n  \"agentDetails\": {\n    \"agentCpuCores\": \"\",\n    \"agentVersion\": \"\",\n    \"componentVersions\": \"\",\n    \"instanceId\": \"\",\n    \"instanceType\": \"\",\n    \"reservedCpuCores\": \"\"\n  },\n  \"discoveryData\": {\n    \"capabilityArns\": \"\",\n    \"privateIpAddresses\": \"\",\n    \"publicIpAddresses\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/agent";

    let payload = json!({
        "agentDetails": json!({
            "agentCpuCores": "",
            "agentVersion": "",
            "componentVersions": "",
            "instanceId": "",
            "instanceType": "",
            "reservedCpuCores": ""
        }),
        "discoveryData": json!({
            "capabilityArns": "",
            "privateIpAddresses": "",
            "publicIpAddresses": ""
        })
    });

    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}}/agent \
  --header 'content-type: application/json' \
  --data '{
  "agentDetails": {
    "agentCpuCores": "",
    "agentVersion": "",
    "componentVersions": "",
    "instanceId": "",
    "instanceType": "",
    "reservedCpuCores": ""
  },
  "discoveryData": {
    "capabilityArns": "",
    "privateIpAddresses": "",
    "publicIpAddresses": ""
  }
}'

echo '{
  "agentDetails": {
    "agentCpuCores": "",
    "agentVersion": "",
    "componentVersions": "",
    "instanceId": "",
    "instanceType": "",
    "reservedCpuCores": ""
  },
  "discoveryData": {
    "capabilityArns": "",
    "privateIpAddresses": "",
    "publicIpAddresses": ""
  }
}' |  \
  http POST {{baseUrl}}/agent \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "agentDetails": {\n    "agentCpuCores": "",\n    "agentVersion": "",\n    "componentVersions": "",\n    "instanceId": "",\n    "instanceType": "",\n    "reservedCpuCores": ""\n  },\n  "discoveryData": {\n    "capabilityArns": "",\n    "privateIpAddresses": "",\n    "publicIpAddresses": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/agent

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "agentDetails": [
    "agentCpuCores": "",
    "agentVersion": "",
    "componentVersions": "",
    "instanceId": "",
    "instanceType": "",
    "reservedCpuCores": ""
  ],
  "discoveryData": [
    "capabilityArns": "",
    "privateIpAddresses": "",
    "publicIpAddresses": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/agent")! 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 ReserveContact

{{baseUrl}}/contact

BODY json

{
  "endTime": "",
  "groundStation": "",
  "missionProfileArn": "",
  "satelliteArn": "",
  "startTime": "",
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/contact");

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  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/contact" {:content-type :json
                                                    :form-params {:endTime ""
                                                                  :groundStation ""
                                                                  :missionProfileArn ""
                                                                  :satelliteArn ""
                                                                  :startTime ""
                                                                  :tags {}}})

require "http/client"

url = "{{baseUrl}}/contact"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\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}}/contact"),
    Content = new StringContent("{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\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}}/contact");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/contact"

	payload := strings.NewReader("{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\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/contact HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 124

{
  "endTime": "",
  "groundStation": "",
  "missionProfileArn": "",
  "satelliteArn": "",
  "startTime": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/contact")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/contact"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\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  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/contact")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/contact")
  .header("content-type", "application/json")
  .body("{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  endTime: '',
  groundStation: '',
  missionProfileArn: '',
  satelliteArn: '',
  startTime: '',
  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}}/contact');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contact',
  headers: {'content-type': 'application/json'},
  data: {
    endTime: '',
    groundStation: '',
    missionProfileArn: '',
    satelliteArn: '',
    startTime: '',
    tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/contact';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"endTime":"","groundStation":"","missionProfileArn":"","satelliteArn":"","startTime":"","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}}/contact',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "endTime": "",\n  "groundStation": "",\n  "missionProfileArn": "",\n  "satelliteArn": "",\n  "startTime": "",\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  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/contact")
  .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/contact',
  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({
  endTime: '',
  groundStation: '',
  missionProfileArn: '',
  satelliteArn: '',
  startTime: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/contact',
  headers: {'content-type': 'application/json'},
  body: {
    endTime: '',
    groundStation: '',
    missionProfileArn: '',
    satelliteArn: '',
    startTime: '',
    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}}/contact');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  endTime: '',
  groundStation: '',
  missionProfileArn: '',
  satelliteArn: '',
  startTime: '',
  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}}/contact',
  headers: {'content-type': 'application/json'},
  data: {
    endTime: '',
    groundStation: '',
    missionProfileArn: '',
    satelliteArn: '',
    startTime: '',
    tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/contact';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"endTime":"","groundStation":"","missionProfileArn":"","satelliteArn":"","startTime":"","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 = @{ @"endTime": @"",
                              @"groundStation": @"",
                              @"missionProfileArn": @"",
                              @"satelliteArn": @"",
                              @"startTime": @"",
                              @"tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/contact"]
                                                       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}}/contact" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"tags\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/contact",
  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([
    'endTime' => '',
    'groundStation' => '',
    'missionProfileArn' => '',
    'satelliteArn' => '',
    'startTime' => '',
    '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}}/contact', [
  'body' => '{
  "endTime": "",
  "groundStation": "",
  "missionProfileArn": "",
  "satelliteArn": "",
  "startTime": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/contact');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'endTime' => '',
  'groundStation' => '',
  'missionProfileArn' => '',
  'satelliteArn' => '',
  'startTime' => '',
  'tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'endTime' => '',
  'groundStation' => '',
  'missionProfileArn' => '',
  'satelliteArn' => '',
  'startTime' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/contact');
$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}}/contact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "endTime": "",
  "groundStation": "",
  "missionProfileArn": "",
  "satelliteArn": "",
  "startTime": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/contact' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "endTime": "",
  "groundStation": "",
  "missionProfileArn": "",
  "satelliteArn": "",
  "startTime": "",
  "tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\n  \"tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/contact", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/contact"

payload = {
    "endTime": "",
    "groundStation": "",
    "missionProfileArn": "",
    "satelliteArn": "",
    "startTime": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/contact"

payload <- "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\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}}/contact")

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  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\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/contact') do |req|
  req.body = "{\n  \"endTime\": \"\",\n  \"groundStation\": \"\",\n  \"missionProfileArn\": \"\",\n  \"satelliteArn\": \"\",\n  \"startTime\": \"\",\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}}/contact";

    let payload = json!({
        "endTime": "",
        "groundStation": "",
        "missionProfileArn": "",
        "satelliteArn": "",
        "startTime": "",
        "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}}/contact \
  --header 'content-type: application/json' \
  --data '{
  "endTime": "",
  "groundStation": "",
  "missionProfileArn": "",
  "satelliteArn": "",
  "startTime": "",
  "tags": {}
}'

echo '{
  "endTime": "",
  "groundStation": "",
  "missionProfileArn": "",
  "satelliteArn": "",
  "startTime": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/contact \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "endTime": "",\n  "groundStation": "",\n  "missionProfileArn": "",\n  "satelliteArn": "",\n  "startTime": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/contact

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "endTime": "",
  "groundStation": "",
  "missionProfileArn": "",
  "satelliteArn": "",
  "startTime": "",
  "tags": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/contact")! 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 TagResource

{{baseUrl}}/tags/:resourceArn

QUERY PARAMS

resourceArn

BODY json

{
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn");

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/post "{{baseUrl}}/tags/:resourceArn" {:content-type :json
                                                              :form-params {:tags {}}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\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}}/tags/:resourceArn"),
    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/:resourceArn");
var request = new RestRequest("", Method.Post);
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/:resourceArn"

	payload := strings.NewReader("{\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/tags/:resourceArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tags/:resourceArn")
  .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/:resourceArn"))
    .header("content-type", "application/json")
    .method("POST", 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/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/tags/:resourceArn")
  .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('POST', '{{baseUrl}}/tags/:resourceArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  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/:resourceArn';
const options = {
  method: 'POST',
  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/:resourceArn',
  method: 'POST',
  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/:resourceArn")
  .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/tags/:resourceArn',
  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: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  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('POST', '{{baseUrl}}/tags/:resourceArn');

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: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  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/:resourceArn';
const options = {
  method: 'POST',
  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/:resourceArn"]
                                                       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}}/tags/:resourceArn" 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 `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn",
  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([
    '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}}/tags/:resourceArn', [
  'body' => '{
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn');
$request->setMethod(HTTP_METH_POST);

$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/:resourceArn');
$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}}/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn' -Method POST -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("POST", "/baseUrl/tags/:resourceArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn"

payload = { "tags": {} }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

payload <- "{\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}}/tags/:resourceArn")

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  \"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/tags/:resourceArn') do |req|
  req.body = "{\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}}/tags/:resourceArn";

    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.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/tags/:resourceArn \
  --header 'content-type: application/json' \
  --data '{
  "tags": {}
}'

echo '{
  "tags": {}
}' |  \
  http POST {{baseUrl}}/tags/:resourceArn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

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/:resourceArn")! 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/:resourceArn#tagKeys

QUERY PARAMS

tagKeys

resourceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/tags/:resourceArn#tagKeys" {:query-params {:tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn?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/:resourceArn?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/:resourceArn?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/:resourceArn?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/:resourceArn?tagKeys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn?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/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/tags/:resourceArn?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/:resourceArn?tagKeys=#tagKeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn?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/:resourceArn?tagKeys=#tagKeys',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn?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/:resourceArn?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/:resourceArn#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/:resourceArn#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/:resourceArn#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/:resourceArn?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/:resourceArn?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/:resourceArn?tagKeys=#tagKeys" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn?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/:resourceArn?tagKeys=#tagKeys');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn#tagKeys');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'tagKeys' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags/:resourceArn#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/:resourceArn?tagKeys=#tagKeys' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/tags/:resourceArn?tagKeys=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn#tagKeys"

querystring = {"tagKeys":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn#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/:resourceArn?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/:resourceArn') 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/:resourceArn#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/:resourceArn?tagKeys=#tagKeys'

http DELETE '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn?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()

PUT UpdateAgentStatus

{{baseUrl}}/agent/:agentId

QUERY PARAMS

agentId

BODY json

{
  "aggregateStatus": {
    "signatureMap": "",
    "status": ""
  },
  "componentStatuses": [
    {
      "bytesReceived": "",
      "bytesSent": "",
      "capabilityArn": "",
      "componentType": "",
      "dataflowId": "",
      "packetsDropped": "",
      "status": ""
    }
  ],
  "taskId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/agent/:agentId");

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  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/agent/:agentId" {:content-type :json
                                                          :form-params {:aggregateStatus {:signatureMap ""
                                                                                          :status ""}
                                                                        :componentStatuses [{:bytesReceived ""
                                                                                             :bytesSent ""
                                                                                             :capabilityArn ""
                                                                                             :componentType ""
                                                                                             :dataflowId ""
                                                                                             :packetsDropped ""
                                                                                             :status ""}]
                                                                        :taskId ""}})

require "http/client"

url = "{{baseUrl}}/agent/:agentId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\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}}/agent/:agentId"),
    Content = new StringContent("{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\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}}/agent/:agentId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/agent/:agentId"

	payload := strings.NewReader("{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\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/agent/:agentId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 304

{
  "aggregateStatus": {
    "signatureMap": "",
    "status": ""
  },
  "componentStatuses": [
    {
      "bytesReceived": "",
      "bytesSent": "",
      "capabilityArn": "",
      "componentType": "",
      "dataflowId": "",
      "packetsDropped": "",
      "status": ""
    }
  ],
  "taskId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/agent/:agentId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/agent/:agentId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\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  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/agent/:agentId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/agent/:agentId")
  .header("content-type", "application/json")
  .body("{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  aggregateStatus: {
    signatureMap: '',
    status: ''
  },
  componentStatuses: [
    {
      bytesReceived: '',
      bytesSent: '',
      capabilityArn: '',
      componentType: '',
      dataflowId: '',
      packetsDropped: '',
      status: ''
    }
  ],
  taskId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/agent/:agentId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/agent/:agentId',
  headers: {'content-type': 'application/json'},
  data: {
    aggregateStatus: {signatureMap: '', status: ''},
    componentStatuses: [
      {
        bytesReceived: '',
        bytesSent: '',
        capabilityArn: '',
        componentType: '',
        dataflowId: '',
        packetsDropped: '',
        status: ''
      }
    ],
    taskId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/agent/:agentId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"aggregateStatus":{"signatureMap":"","status":""},"componentStatuses":[{"bytesReceived":"","bytesSent":"","capabilityArn":"","componentType":"","dataflowId":"","packetsDropped":"","status":""}],"taskId":""}'
};

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}}/agent/:agentId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "aggregateStatus": {\n    "signatureMap": "",\n    "status": ""\n  },\n  "componentStatuses": [\n    {\n      "bytesReceived": "",\n      "bytesSent": "",\n      "capabilityArn": "",\n      "componentType": "",\n      "dataflowId": "",\n      "packetsDropped": "",\n      "status": ""\n    }\n  ],\n  "taskId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/agent/:agentId")
  .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/agent/:agentId',
  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({
  aggregateStatus: {signatureMap: '', status: ''},
  componentStatuses: [
    {
      bytesReceived: '',
      bytesSent: '',
      capabilityArn: '',
      componentType: '',
      dataflowId: '',
      packetsDropped: '',
      status: ''
    }
  ],
  taskId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/agent/:agentId',
  headers: {'content-type': 'application/json'},
  body: {
    aggregateStatus: {signatureMap: '', status: ''},
    componentStatuses: [
      {
        bytesReceived: '',
        bytesSent: '',
        capabilityArn: '',
        componentType: '',
        dataflowId: '',
        packetsDropped: '',
        status: ''
      }
    ],
    taskId: ''
  },
  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}}/agent/:agentId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  aggregateStatus: {
    signatureMap: '',
    status: ''
  },
  componentStatuses: [
    {
      bytesReceived: '',
      bytesSent: '',
      capabilityArn: '',
      componentType: '',
      dataflowId: '',
      packetsDropped: '',
      status: ''
    }
  ],
  taskId: ''
});

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}}/agent/:agentId',
  headers: {'content-type': 'application/json'},
  data: {
    aggregateStatus: {signatureMap: '', status: ''},
    componentStatuses: [
      {
        bytesReceived: '',
        bytesSent: '',
        capabilityArn: '',
        componentType: '',
        dataflowId: '',
        packetsDropped: '',
        status: ''
      }
    ],
    taskId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/agent/:agentId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"aggregateStatus":{"signatureMap":"","status":""},"componentStatuses":[{"bytesReceived":"","bytesSent":"","capabilityArn":"","componentType":"","dataflowId":"","packetsDropped":"","status":""}],"taskId":""}'
};

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 = @{ @"aggregateStatus": @{ @"signatureMap": @"", @"status": @"" },
                              @"componentStatuses": @[ @{ @"bytesReceived": @"", @"bytesSent": @"", @"capabilityArn": @"", @"componentType": @"", @"dataflowId": @"", @"packetsDropped": @"", @"status": @"" } ],
                              @"taskId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/agent/:agentId"]
                                                       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}}/agent/:agentId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/agent/:agentId",
  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([
    'aggregateStatus' => [
        'signatureMap' => '',
        'status' => ''
    ],
    'componentStatuses' => [
        [
                'bytesReceived' => '',
                'bytesSent' => '',
                'capabilityArn' => '',
                'componentType' => '',
                'dataflowId' => '',
                'packetsDropped' => '',
                'status' => ''
        ]
    ],
    'taskId' => ''
  ]),
  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}}/agent/:agentId', [
  'body' => '{
  "aggregateStatus": {
    "signatureMap": "",
    "status": ""
  },
  "componentStatuses": [
    {
      "bytesReceived": "",
      "bytesSent": "",
      "capabilityArn": "",
      "componentType": "",
      "dataflowId": "",
      "packetsDropped": "",
      "status": ""
    }
  ],
  "taskId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/agent/:agentId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'aggregateStatus' => [
    'signatureMap' => '',
    'status' => ''
  ],
  'componentStatuses' => [
    [
        'bytesReceived' => '',
        'bytesSent' => '',
        'capabilityArn' => '',
        'componentType' => '',
        'dataflowId' => '',
        'packetsDropped' => '',
        'status' => ''
    ]
  ],
  'taskId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'aggregateStatus' => [
    'signatureMap' => '',
    'status' => ''
  ],
  'componentStatuses' => [
    [
        'bytesReceived' => '',
        'bytesSent' => '',
        'capabilityArn' => '',
        'componentType' => '',
        'dataflowId' => '',
        'packetsDropped' => '',
        'status' => ''
    ]
  ],
  'taskId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/agent/:agentId');
$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}}/agent/:agentId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "aggregateStatus": {
    "signatureMap": "",
    "status": ""
  },
  "componentStatuses": [
    {
      "bytesReceived": "",
      "bytesSent": "",
      "capabilityArn": "",
      "componentType": "",
      "dataflowId": "",
      "packetsDropped": "",
      "status": ""
    }
  ],
  "taskId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/agent/:agentId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "aggregateStatus": {
    "signatureMap": "",
    "status": ""
  },
  "componentStatuses": [
    {
      "bytesReceived": "",
      "bytesSent": "",
      "capabilityArn": "",
      "componentType": "",
      "dataflowId": "",
      "packetsDropped": "",
      "status": ""
    }
  ],
  "taskId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/agent/:agentId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/agent/:agentId"

payload = {
    "aggregateStatus": {
        "signatureMap": "",
        "status": ""
    },
    "componentStatuses": [
        {
            "bytesReceived": "",
            "bytesSent": "",
            "capabilityArn": "",
            "componentType": "",
            "dataflowId": "",
            "packetsDropped": "",
            "status": ""
        }
    ],
    "taskId": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/agent/:agentId"

payload <- "{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\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}}/agent/:agentId")

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  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\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/agent/:agentId') do |req|
  req.body = "{\n  \"aggregateStatus\": {\n    \"signatureMap\": \"\",\n    \"status\": \"\"\n  },\n  \"componentStatuses\": [\n    {\n      \"bytesReceived\": \"\",\n      \"bytesSent\": \"\",\n      \"capabilityArn\": \"\",\n      \"componentType\": \"\",\n      \"dataflowId\": \"\",\n      \"packetsDropped\": \"\",\n      \"status\": \"\"\n    }\n  ],\n  \"taskId\": \"\"\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}}/agent/:agentId";

    let payload = json!({
        "aggregateStatus": json!({
            "signatureMap": "",
            "status": ""
        }),
        "componentStatuses": (
            json!({
                "bytesReceived": "",
                "bytesSent": "",
                "capabilityArn": "",
                "componentType": "",
                "dataflowId": "",
                "packetsDropped": "",
                "status": ""
            })
        ),
        "taskId": ""
    });

    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}}/agent/:agentId \
  --header 'content-type: application/json' \
  --data '{
  "aggregateStatus": {
    "signatureMap": "",
    "status": ""
  },
  "componentStatuses": [
    {
      "bytesReceived": "",
      "bytesSent": "",
      "capabilityArn": "",
      "componentType": "",
      "dataflowId": "",
      "packetsDropped": "",
      "status": ""
    }
  ],
  "taskId": ""
}'

echo '{
  "aggregateStatus": {
    "signatureMap": "",
    "status": ""
  },
  "componentStatuses": [
    {
      "bytesReceived": "",
      "bytesSent": "",
      "capabilityArn": "",
      "componentType": "",
      "dataflowId": "",
      "packetsDropped": "",
      "status": ""
    }
  ],
  "taskId": ""
}' |  \
  http PUT {{baseUrl}}/agent/:agentId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "aggregateStatus": {\n    "signatureMap": "",\n    "status": ""\n  },\n  "componentStatuses": [\n    {\n      "bytesReceived": "",\n      "bytesSent": "",\n      "capabilityArn": "",\n      "componentType": "",\n      "dataflowId": "",\n      "packetsDropped": "",\n      "status": ""\n    }\n  ],\n  "taskId": ""\n}' \
  --output-document \
  - {{baseUrl}}/agent/:agentId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "aggregateStatus": [
    "signatureMap": "",
    "status": ""
  ],
  "componentStatuses": [
    [
      "bytesReceived": "",
      "bytesSent": "",
      "capabilityArn": "",
      "componentType": "",
      "dataflowId": "",
      "packetsDropped": "",
      "status": ""
    ]
  ],
  "taskId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/agent/:agentId")! 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 UpdateConfig

{{baseUrl}}/config/:configType/:configId

QUERY PARAMS

configId

configType

BODY json

{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/config/:configType/:configId");

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  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/config/:configType/:configId" {:content-type :json
                                                                        :form-params {:configData {:antennaDownlinkConfig ""
                                                                                                   :antennaDownlinkDemodDecodeConfig ""
                                                                                                   :antennaUplinkConfig ""
                                                                                                   :dataflowEndpointConfig ""
                                                                                                   :s3RecordingConfig ""
                                                                                                   :trackingConfig ""
                                                                                                   :uplinkEchoConfig ""}
                                                                                      :name ""}})

require "http/client"

url = "{{baseUrl}}/config/:configType/:configId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\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}}/config/:configType/:configId"),
    Content = new StringContent("{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\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}}/config/:configType/:configId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/config/:configType/:configId"

	payload := strings.NewReader("{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\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/config/:configType/:configId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 263

{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/config/:configType/:configId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/config/:configType/:configId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\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  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/config/:configType/:configId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/config/:configType/:configId")
  .header("content-type", "application/json")
  .body("{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  configData: {
    antennaDownlinkConfig: '',
    antennaDownlinkDemodDecodeConfig: '',
    antennaUplinkConfig: '',
    dataflowEndpointConfig: '',
    s3RecordingConfig: '',
    trackingConfig: '',
    uplinkEchoConfig: ''
  },
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/config/:configType/:configId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/config/:configType/:configId',
  headers: {'content-type': 'application/json'},
  data: {
    configData: {
      antennaDownlinkConfig: '',
      antennaDownlinkDemodDecodeConfig: '',
      antennaUplinkConfig: '',
      dataflowEndpointConfig: '',
      s3RecordingConfig: '',
      trackingConfig: '',
      uplinkEchoConfig: ''
    },
    name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/config/:configType/:configId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"configData":{"antennaDownlinkConfig":"","antennaDownlinkDemodDecodeConfig":"","antennaUplinkConfig":"","dataflowEndpointConfig":"","s3RecordingConfig":"","trackingConfig":"","uplinkEchoConfig":""},"name":""}'
};

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}}/config/:configType/:configId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "configData": {\n    "antennaDownlinkConfig": "",\n    "antennaDownlinkDemodDecodeConfig": "",\n    "antennaUplinkConfig": "",\n    "dataflowEndpointConfig": "",\n    "s3RecordingConfig": "",\n    "trackingConfig": "",\n    "uplinkEchoConfig": ""\n  },\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/config/:configType/:configId")
  .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/config/:configType/:configId',
  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({
  configData: {
    antennaDownlinkConfig: '',
    antennaDownlinkDemodDecodeConfig: '',
    antennaUplinkConfig: '',
    dataflowEndpointConfig: '',
    s3RecordingConfig: '',
    trackingConfig: '',
    uplinkEchoConfig: ''
  },
  name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/config/:configType/:configId',
  headers: {'content-type': 'application/json'},
  body: {
    configData: {
      antennaDownlinkConfig: '',
      antennaDownlinkDemodDecodeConfig: '',
      antennaUplinkConfig: '',
      dataflowEndpointConfig: '',
      s3RecordingConfig: '',
      trackingConfig: '',
      uplinkEchoConfig: ''
    },
    name: ''
  },
  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}}/config/:configType/:configId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  configData: {
    antennaDownlinkConfig: '',
    antennaDownlinkDemodDecodeConfig: '',
    antennaUplinkConfig: '',
    dataflowEndpointConfig: '',
    s3RecordingConfig: '',
    trackingConfig: '',
    uplinkEchoConfig: ''
  },
  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: 'PUT',
  url: '{{baseUrl}}/config/:configType/:configId',
  headers: {'content-type': 'application/json'},
  data: {
    configData: {
      antennaDownlinkConfig: '',
      antennaDownlinkDemodDecodeConfig: '',
      antennaUplinkConfig: '',
      dataflowEndpointConfig: '',
      s3RecordingConfig: '',
      trackingConfig: '',
      uplinkEchoConfig: ''
    },
    name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/config/:configType/:configId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"configData":{"antennaDownlinkConfig":"","antennaDownlinkDemodDecodeConfig":"","antennaUplinkConfig":"","dataflowEndpointConfig":"","s3RecordingConfig":"","trackingConfig":"","uplinkEchoConfig":""},"name":""}'
};

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 = @{ @"configData": @{ @"antennaDownlinkConfig": @"", @"antennaDownlinkDemodDecodeConfig": @"", @"antennaUplinkConfig": @"", @"dataflowEndpointConfig": @"", @"s3RecordingConfig": @"", @"trackingConfig": @"", @"uplinkEchoConfig": @"" },
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/config/:configType/:configId"]
                                                       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}}/config/:configType/:configId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/config/:configType/:configId",
  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([
    'configData' => [
        'antennaDownlinkConfig' => '',
        'antennaDownlinkDemodDecodeConfig' => '',
        'antennaUplinkConfig' => '',
        'dataflowEndpointConfig' => '',
        's3RecordingConfig' => '',
        'trackingConfig' => '',
        'uplinkEchoConfig' => ''
    ],
    'name' => ''
  ]),
  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}}/config/:configType/:configId', [
  'body' => '{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/config/:configType/:configId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'configData' => [
    'antennaDownlinkConfig' => '',
    'antennaDownlinkDemodDecodeConfig' => '',
    'antennaUplinkConfig' => '',
    'dataflowEndpointConfig' => '',
    's3RecordingConfig' => '',
    'trackingConfig' => '',
    'uplinkEchoConfig' => ''
  ],
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'configData' => [
    'antennaDownlinkConfig' => '',
    'antennaDownlinkDemodDecodeConfig' => '',
    'antennaUplinkConfig' => '',
    'dataflowEndpointConfig' => '',
    's3RecordingConfig' => '',
    'trackingConfig' => '',
    'uplinkEchoConfig' => ''
  ],
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/config/:configType/:configId');
$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}}/config/:configType/:configId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/config/:configType/:configId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/config/:configType/:configId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/config/:configType/:configId"

payload = {
    "configData": {
        "antennaDownlinkConfig": "",
        "antennaDownlinkDemodDecodeConfig": "",
        "antennaUplinkConfig": "",
        "dataflowEndpointConfig": "",
        "s3RecordingConfig": "",
        "trackingConfig": "",
        "uplinkEchoConfig": ""
    },
    "name": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/config/:configType/:configId"

payload <- "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\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}}/config/:configType/:configId")

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  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\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/config/:configType/:configId') do |req|
  req.body = "{\n  \"configData\": {\n    \"antennaDownlinkConfig\": \"\",\n    \"antennaDownlinkDemodDecodeConfig\": \"\",\n    \"antennaUplinkConfig\": \"\",\n    \"dataflowEndpointConfig\": \"\",\n    \"s3RecordingConfig\": \"\",\n    \"trackingConfig\": \"\",\n    \"uplinkEchoConfig\": \"\"\n  },\n  \"name\": \"\"\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}}/config/:configType/:configId";

    let payload = json!({
        "configData": json!({
            "antennaDownlinkConfig": "",
            "antennaDownlinkDemodDecodeConfig": "",
            "antennaUplinkConfig": "",
            "dataflowEndpointConfig": "",
            "s3RecordingConfig": "",
            "trackingConfig": "",
            "uplinkEchoConfig": ""
        }),
        "name": ""
    });

    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}}/config/:configType/:configId \
  --header 'content-type: application/json' \
  --data '{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": ""
}'

echo '{
  "configData": {
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  },
  "name": ""
}' |  \
  http PUT {{baseUrl}}/config/:configType/:configId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "configData": {\n    "antennaDownlinkConfig": "",\n    "antennaDownlinkDemodDecodeConfig": "",\n    "antennaUplinkConfig": "",\n    "dataflowEndpointConfig": "",\n    "s3RecordingConfig": "",\n    "trackingConfig": "",\n    "uplinkEchoConfig": ""\n  },\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/config/:configType/:configId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "configData": [
    "antennaDownlinkConfig": "",
    "antennaDownlinkDemodDecodeConfig": "",
    "antennaUplinkConfig": "",
    "dataflowEndpointConfig": "",
    "s3RecordingConfig": "",
    "trackingConfig": "",
    "uplinkEchoConfig": ""
  ],
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/config/:configType/:configId")! 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 UpdateEphemeris

{{baseUrl}}/ephemeris/:ephemerisId

QUERY PARAMS

ephemerisId

BODY json

{
  "enabled": false,
  "name": "",
  "priority": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ephemeris/:ephemerisId");

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  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/ephemeris/:ephemerisId" {:content-type :json
                                                                  :form-params {:enabled false
                                                                                :name ""
                                                                                :priority 0}})

require "http/client"

url = "{{baseUrl}}/ephemeris/:ephemerisId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\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}}/ephemeris/:ephemerisId"),
    Content = new StringContent("{\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 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}}/ephemeris/:ephemerisId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ephemeris/:ephemerisId"

	payload := strings.NewReader("{\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\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/ephemeris/:ephemerisId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "enabled": false,
  "name": "",
  "priority": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/ephemeris/:ephemerisId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ephemeris/:ephemerisId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 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  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/ephemeris/:ephemerisId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/ephemeris/:ephemerisId")
  .header("content-type", "application/json")
  .body("{\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\n}")
  .asString();

const data = JSON.stringify({
  enabled: false,
  name: '',
  priority: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/ephemeris/:ephemerisId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/ephemeris/:ephemerisId',
  headers: {'content-type': 'application/json'},
  data: {enabled: false, name: '', priority: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ephemeris/:ephemerisId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"enabled":false,"name":"","priority":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}}/ephemeris/:ephemerisId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "enabled": false,\n  "name": "",\n  "priority": 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  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/ephemeris/:ephemerisId")
  .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/ephemeris/:ephemerisId',
  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({enabled: false, name: '', priority: 0}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/ephemeris/:ephemerisId',
  headers: {'content-type': 'application/json'},
  body: {enabled: false, name: '', priority: 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('PUT', '{{baseUrl}}/ephemeris/:ephemerisId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  enabled: false,
  name: '',
  priority: 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: 'PUT',
  url: '{{baseUrl}}/ephemeris/:ephemerisId',
  headers: {'content-type': 'application/json'},
  data: {enabled: false, name: '', priority: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ephemeris/:ephemerisId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"enabled":false,"name":"","priority":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 = @{ @"enabled": @NO,
                              @"name": @"",
                              @"priority": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ephemeris/:ephemerisId"]
                                                       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}}/ephemeris/:ephemerisId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ephemeris/:ephemerisId",
  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([
    'enabled' => null,
    'name' => '',
    'priority' => 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('PUT', '{{baseUrl}}/ephemeris/:ephemerisId', [
  'body' => '{
  "enabled": false,
  "name": "",
  "priority": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/ephemeris/:ephemerisId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'enabled' => null,
  'name' => '',
  'priority' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'enabled' => null,
  'name' => '',
  'priority' => 0
]));
$request->setRequestUrl('{{baseUrl}}/ephemeris/:ephemerisId');
$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}}/ephemeris/:ephemerisId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "enabled": false,
  "name": "",
  "priority": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ephemeris/:ephemerisId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "enabled": false,
  "name": "",
  "priority": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/ephemeris/:ephemerisId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ephemeris/:ephemerisId"

payload = {
    "enabled": False,
    "name": "",
    "priority": 0
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ephemeris/:ephemerisId"

payload <- "{\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\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}}/ephemeris/:ephemerisId")

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  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 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.put('/baseUrl/ephemeris/:ephemerisId') do |req|
  req.body = "{\n  \"enabled\": false,\n  \"name\": \"\",\n  \"priority\": 0\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}}/ephemeris/:ephemerisId";

    let payload = json!({
        "enabled": false,
        "name": "",
        "priority": 0
    });

    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}}/ephemeris/:ephemerisId \
  --header 'content-type: application/json' \
  --data '{
  "enabled": false,
  "name": "",
  "priority": 0
}'

echo '{
  "enabled": false,
  "name": "",
  "priority": 0
}' |  \
  http PUT {{baseUrl}}/ephemeris/:ephemerisId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "enabled": false,\n  "name": "",\n  "priority": 0\n}' \
  --output-document \
  - {{baseUrl}}/ephemeris/:ephemerisId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "enabled": false,
  "name": "",
  "priority": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ephemeris/:ephemerisId")! 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 UpdateMissionProfile

{{baseUrl}}/missionprofile/:missionProfileId

QUERY PARAMS

missionProfileId

BODY json

{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "trackingConfigArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/missionprofile/:missionProfileId");

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  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/missionprofile/:missionProfileId" {:content-type :json
                                                                            :form-params {:contactPostPassDurationSeconds 0
                                                                                          :contactPrePassDurationSeconds 0
                                                                                          :dataflowEdges []
                                                                                          :minimumViableContactDurationSeconds 0
                                                                                          :name ""
                                                                                          :streamsKmsKey {:kmsAliasArn ""
                                                                                                          :kmsKeyArn ""}
                                                                                          :streamsKmsRole ""
                                                                                          :trackingConfigArn ""}})

require "http/client"

url = "{{baseUrl}}/missionprofile/:missionProfileId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\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}}/missionprofile/:missionProfileId"),
    Content = new StringContent("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\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}}/missionprofile/:missionProfileId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/missionprofile/:missionProfileId"

	payload := strings.NewReader("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\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/missionprofile/:missionProfileId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 280

{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "trackingConfigArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/missionprofile/:missionProfileId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/missionprofile/:missionProfileId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\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  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/missionprofile/:missionProfileId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/missionprofile/:missionProfileId")
  .header("content-type", "application/json")
  .body("{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  contactPostPassDurationSeconds: 0,
  contactPrePassDurationSeconds: 0,
  dataflowEdges: [],
  minimumViableContactDurationSeconds: 0,
  name: '',
  streamsKmsKey: {
    kmsAliasArn: '',
    kmsKeyArn: ''
  },
  streamsKmsRole: '',
  trackingConfigArn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/missionprofile/:missionProfileId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/missionprofile/:missionProfileId',
  headers: {'content-type': 'application/json'},
  data: {
    contactPostPassDurationSeconds: 0,
    contactPrePassDurationSeconds: 0,
    dataflowEdges: [],
    minimumViableContactDurationSeconds: 0,
    name: '',
    streamsKmsKey: {kmsAliasArn: '', kmsKeyArn: ''},
    streamsKmsRole: '',
    trackingConfigArn: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/missionprofile/:missionProfileId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"contactPostPassDurationSeconds":0,"contactPrePassDurationSeconds":0,"dataflowEdges":[],"minimumViableContactDurationSeconds":0,"name":"","streamsKmsKey":{"kmsAliasArn":"","kmsKeyArn":""},"streamsKmsRole":"","trackingConfigArn":""}'
};

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}}/missionprofile/:missionProfileId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "contactPostPassDurationSeconds": 0,\n  "contactPrePassDurationSeconds": 0,\n  "dataflowEdges": [],\n  "minimumViableContactDurationSeconds": 0,\n  "name": "",\n  "streamsKmsKey": {\n    "kmsAliasArn": "",\n    "kmsKeyArn": ""\n  },\n  "streamsKmsRole": "",\n  "trackingConfigArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/missionprofile/:missionProfileId")
  .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/missionprofile/:missionProfileId',
  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({
  contactPostPassDurationSeconds: 0,
  contactPrePassDurationSeconds: 0,
  dataflowEdges: [],
  minimumViableContactDurationSeconds: 0,
  name: '',
  streamsKmsKey: {kmsAliasArn: '', kmsKeyArn: ''},
  streamsKmsRole: '',
  trackingConfigArn: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/missionprofile/:missionProfileId',
  headers: {'content-type': 'application/json'},
  body: {
    contactPostPassDurationSeconds: 0,
    contactPrePassDurationSeconds: 0,
    dataflowEdges: [],
    minimumViableContactDurationSeconds: 0,
    name: '',
    streamsKmsKey: {kmsAliasArn: '', kmsKeyArn: ''},
    streamsKmsRole: '',
    trackingConfigArn: ''
  },
  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}}/missionprofile/:missionProfileId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  contactPostPassDurationSeconds: 0,
  contactPrePassDurationSeconds: 0,
  dataflowEdges: [],
  minimumViableContactDurationSeconds: 0,
  name: '',
  streamsKmsKey: {
    kmsAliasArn: '',
    kmsKeyArn: ''
  },
  streamsKmsRole: '',
  trackingConfigArn: ''
});

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}}/missionprofile/:missionProfileId',
  headers: {'content-type': 'application/json'},
  data: {
    contactPostPassDurationSeconds: 0,
    contactPrePassDurationSeconds: 0,
    dataflowEdges: [],
    minimumViableContactDurationSeconds: 0,
    name: '',
    streamsKmsKey: {kmsAliasArn: '', kmsKeyArn: ''},
    streamsKmsRole: '',
    trackingConfigArn: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/missionprofile/:missionProfileId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"contactPostPassDurationSeconds":0,"contactPrePassDurationSeconds":0,"dataflowEdges":[],"minimumViableContactDurationSeconds":0,"name":"","streamsKmsKey":{"kmsAliasArn":"","kmsKeyArn":""},"streamsKmsRole":"","trackingConfigArn":""}'
};

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 = @{ @"contactPostPassDurationSeconds": @0,
                              @"contactPrePassDurationSeconds": @0,
                              @"dataflowEdges": @[  ],
                              @"minimumViableContactDurationSeconds": @0,
                              @"name": @"",
                              @"streamsKmsKey": @{ @"kmsAliasArn": @"", @"kmsKeyArn": @"" },
                              @"streamsKmsRole": @"",
                              @"trackingConfigArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/missionprofile/:missionProfileId"]
                                                       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}}/missionprofile/:missionProfileId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/missionprofile/:missionProfileId",
  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([
    'contactPostPassDurationSeconds' => 0,
    'contactPrePassDurationSeconds' => 0,
    'dataflowEdges' => [
        
    ],
    'minimumViableContactDurationSeconds' => 0,
    'name' => '',
    'streamsKmsKey' => [
        'kmsAliasArn' => '',
        'kmsKeyArn' => ''
    ],
    'streamsKmsRole' => '',
    'trackingConfigArn' => ''
  ]),
  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}}/missionprofile/:missionProfileId', [
  'body' => '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "trackingConfigArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/missionprofile/:missionProfileId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'contactPostPassDurationSeconds' => 0,
  'contactPrePassDurationSeconds' => 0,
  'dataflowEdges' => [
    
  ],
  'minimumViableContactDurationSeconds' => 0,
  'name' => '',
  'streamsKmsKey' => [
    'kmsAliasArn' => '',
    'kmsKeyArn' => ''
  ],
  'streamsKmsRole' => '',
  'trackingConfigArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'contactPostPassDurationSeconds' => 0,
  'contactPrePassDurationSeconds' => 0,
  'dataflowEdges' => [
    
  ],
  'minimumViableContactDurationSeconds' => 0,
  'name' => '',
  'streamsKmsKey' => [
    'kmsAliasArn' => '',
    'kmsKeyArn' => ''
  ],
  'streamsKmsRole' => '',
  'trackingConfigArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/missionprofile/:missionProfileId');
$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}}/missionprofile/:missionProfileId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "trackingConfigArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/missionprofile/:missionProfileId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "trackingConfigArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/missionprofile/:missionProfileId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/missionprofile/:missionProfileId"

payload = {
    "contactPostPassDurationSeconds": 0,
    "contactPrePassDurationSeconds": 0,
    "dataflowEdges": [],
    "minimumViableContactDurationSeconds": 0,
    "name": "",
    "streamsKmsKey": {
        "kmsAliasArn": "",
        "kmsKeyArn": ""
    },
    "streamsKmsRole": "",
    "trackingConfigArn": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/missionprofile/:missionProfileId"

payload <- "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\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}}/missionprofile/:missionProfileId")

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  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\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/missionprofile/:missionProfileId') do |req|
  req.body = "{\n  \"contactPostPassDurationSeconds\": 0,\n  \"contactPrePassDurationSeconds\": 0,\n  \"dataflowEdges\": [],\n  \"minimumViableContactDurationSeconds\": 0,\n  \"name\": \"\",\n  \"streamsKmsKey\": {\n    \"kmsAliasArn\": \"\",\n    \"kmsKeyArn\": \"\"\n  },\n  \"streamsKmsRole\": \"\",\n  \"trackingConfigArn\": \"\"\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}}/missionprofile/:missionProfileId";

    let payload = json!({
        "contactPostPassDurationSeconds": 0,
        "contactPrePassDurationSeconds": 0,
        "dataflowEdges": (),
        "minimumViableContactDurationSeconds": 0,
        "name": "",
        "streamsKmsKey": json!({
            "kmsAliasArn": "",
            "kmsKeyArn": ""
        }),
        "streamsKmsRole": "",
        "trackingConfigArn": ""
    });

    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}}/missionprofile/:missionProfileId \
  --header 'content-type: application/json' \
  --data '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "trackingConfigArn": ""
}'

echo '{
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": {
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  },
  "streamsKmsRole": "",
  "trackingConfigArn": ""
}' |  \
  http PUT {{baseUrl}}/missionprofile/:missionProfileId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "contactPostPassDurationSeconds": 0,\n  "contactPrePassDurationSeconds": 0,\n  "dataflowEdges": [],\n  "minimumViableContactDurationSeconds": 0,\n  "name": "",\n  "streamsKmsKey": {\n    "kmsAliasArn": "",\n    "kmsKeyArn": ""\n  },\n  "streamsKmsRole": "",\n  "trackingConfigArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/missionprofile/:missionProfileId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "contactPostPassDurationSeconds": 0,
  "contactPrePassDurationSeconds": 0,
  "dataflowEdges": [],
  "minimumViableContactDurationSeconds": 0,
  "name": "",
  "streamsKmsKey": [
    "kmsAliasArn": "",
    "kmsKeyArn": ""
  ],
  "streamsKmsRole": "",
  "trackingConfigArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/missionprofile/:missionProfileId")! 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()