AWS MediaConnect

POST AddBridgeOutputs

{{baseUrl}}/v1/bridges/:bridgeArn/outputs

QUERY PARAMS

bridgeArn

BODY json

{
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/bridges/:bridgeArn/outputs");

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  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/bridges/:bridgeArn/outputs" {:content-type :json
                                                                          :form-params {:outputs [{:NetworkOutput ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/bridges/:bridgeArn/outputs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/bridges/:bridgeArn/outputs"),
    Content = new StringContent("{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/bridges/:bridgeArn/outputs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/bridges/:bridgeArn/outputs"

	payload := strings.NewReader("{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/bridges/:bridgeArn/outputs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 60

{
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/bridges/:bridgeArn/outputs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/bridges/:bridgeArn/outputs"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/outputs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/bridges/:bridgeArn/outputs")
  .header("content-type", "application/json")
  .body("{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  outputs: [
    {
      NetworkOutput: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/bridges/:bridgeArn/outputs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/outputs',
  headers: {'content-type': 'application/json'},
  data: {outputs: [{NetworkOutput: ''}]}
};

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

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/outputs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"outputs":[{"NetworkOutput":""}]}'
};

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}}/v1/bridges/:bridgeArn/outputs',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "outputs": [\n    {\n      "NetworkOutput": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/outputs")
  .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/v1/bridges/:bridgeArn/outputs',
  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({outputs: [{NetworkOutput: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/outputs',
  headers: {'content-type': 'application/json'},
  body: {outputs: [{NetworkOutput: ''}]},
  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}}/v1/bridges/:bridgeArn/outputs');

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

req.type('json');
req.send({
  outputs: [
    {
      NetworkOutput: ''
    }
  ]
});

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}}/v1/bridges/:bridgeArn/outputs',
  headers: {'content-type': 'application/json'},
  data: {outputs: [{NetworkOutput: ''}]}
};

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

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

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/outputs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"outputs":[{"NetworkOutput":""}]}'
};

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 = @{ @"outputs": @[ @{ @"NetworkOutput": @"" } ] };

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

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

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

 "{{baseUrl}}/v1/bridges/:bridgeArn/outputs",
  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([
    'outputs' => [
        [
                'NetworkOutput' => ''
        ]
    ]
  ]),
  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}}/v1/bridges/:bridgeArn/outputs', [
  'body' => '{
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/bridges/:bridgeArn/outputs');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'outputs' => [
    [
        'NetworkOutput' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/bridges/:bridgeArn/outputs');
$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}}/v1/bridges/:bridgeArn/outputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/bridges/:bridgeArn/outputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1/bridges/:bridgeArn/outputs", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/bridges/:bridgeArn/outputs"

payload = { "outputs": [{ "NetworkOutput": "" }] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges/:bridgeArn/outputs"

payload <- "{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/bridges/:bridgeArn/outputs")

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  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/bridges/:bridgeArn/outputs') do |req|
  req.body = "{\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"outputs": (json!({"NetworkOutput": ""}))});

    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}}/v1/bridges/:bridgeArn/outputs \
  --header 'content-type: application/json' \
  --data '{
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ]
}'

echo '{
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/bridges/:bridgeArn/outputs \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "outputs": [\n    {\n      "NetworkOutput": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/bridges/:bridgeArn/outputs

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/bridges/:bridgeArn/outputs")! 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 AddBridgeSources

{{baseUrl}}/v1/bridges/:bridgeArn/sources

QUERY PARAMS

bridgeArn

BODY json

{
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/bridges/:bridgeArn/sources");

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  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/bridges/:bridgeArn/sources" {:content-type :json
                                                                          :form-params {:sources [{:FlowSource ""
                                                                                                   :NetworkSource ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/bridges/:bridgeArn/sources"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/bridges/:bridgeArn/sources"),
    Content = new StringContent("{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/bridges/:bridgeArn/sources");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/bridges/:bridgeArn/sources"

	payload := strings.NewReader("{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/bridges/:bridgeArn/sources HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 84

{
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/bridges/:bridgeArn/sources")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/bridges/:bridgeArn/sources"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/sources")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/bridges/:bridgeArn/sources")
  .header("content-type", "application/json")
  .body("{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  sources: [
    {
      FlowSource: '',
      NetworkSource: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/bridges/:bridgeArn/sources');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/sources',
  headers: {'content-type': 'application/json'},
  data: {sources: [{FlowSource: '', NetworkSource: ''}]}
};

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

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/sources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"sources":[{"FlowSource":"","NetworkSource":""}]}'
};

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}}/v1/bridges/:bridgeArn/sources',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "sources": [\n    {\n      "FlowSource": "",\n      "NetworkSource": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/sources")
  .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/v1/bridges/:bridgeArn/sources',
  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({sources: [{FlowSource: '', NetworkSource: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/sources',
  headers: {'content-type': 'application/json'},
  body: {sources: [{FlowSource: '', NetworkSource: ''}]},
  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}}/v1/bridges/:bridgeArn/sources');

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

req.type('json');
req.send({
  sources: [
    {
      FlowSource: '',
      NetworkSource: ''
    }
  ]
});

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}}/v1/bridges/:bridgeArn/sources',
  headers: {'content-type': 'application/json'},
  data: {sources: [{FlowSource: '', NetworkSource: ''}]}
};

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

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

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/sources';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"sources":[{"FlowSource":"","NetworkSource":""}]}'
};

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 = @{ @"sources": @[ @{ @"FlowSource": @"", @"NetworkSource": @"" } ] };

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

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

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

 "{{baseUrl}}/v1/bridges/:bridgeArn/sources",
  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([
    'sources' => [
        [
                'FlowSource' => '',
                'NetworkSource' => ''
        ]
    ]
  ]),
  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}}/v1/bridges/:bridgeArn/sources', [
  'body' => '{
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/bridges/:bridgeArn/sources');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'sources' => [
    [
        'FlowSource' => '',
        'NetworkSource' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'sources' => [
    [
        'FlowSource' => '',
        'NetworkSource' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/bridges/:bridgeArn/sources');
$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}}/v1/bridges/:bridgeArn/sources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/bridges/:bridgeArn/sources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1/bridges/:bridgeArn/sources", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/bridges/:bridgeArn/sources"

payload = { "sources": [
        {
            "FlowSource": "",
            "NetworkSource": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges/:bridgeArn/sources"

payload <- "{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/bridges/:bridgeArn/sources")

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  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/bridges/:bridgeArn/sources') do |req|
  req.body = "{\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"sources": (
            json!({
                "FlowSource": "",
                "NetworkSource": ""
            })
        )});

    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}}/v1/bridges/:bridgeArn/sources \
  --header 'content-type: application/json' \
  --data '{
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}'

echo '{
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/bridges/:bridgeArn/sources \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "sources": [\n    {\n      "FlowSource": "",\n      "NetworkSource": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/bridges/:bridgeArn/sources

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/bridges/:bridgeArn/sources")! 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 AddFlowMediaStreams

{{baseUrl}}/v1/flows/:flowArn/mediaStreams

QUERY PARAMS

flowArn

BODY json

{
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/mediaStreams");

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  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/flows/:flowArn/mediaStreams" {:content-type :json
                                                                           :form-params {:mediaStreams [{:Attributes ""
                                                                                                         :ClockRate ""
                                                                                                         :Description ""
                                                                                                         :MediaStreamId ""
                                                                                                         :MediaStreamName ""
                                                                                                         :MediaStreamType ""
                                                                                                         :VideoFormat ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/mediaStreams"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/flows/:flowArn/mediaStreams"),
    Content = new StringContent("{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/:flowArn/mediaStreams");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/mediaStreams"

	payload := strings.NewReader("{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/flows/:flowArn/mediaStreams HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 220

{
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/flows/:flowArn/mediaStreams")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/mediaStreams"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/mediaStreams")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/flows/:flowArn/mediaStreams")
  .header("content-type", "application/json")
  .body("{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  mediaStreams: [
    {
      Attributes: '',
      ClockRate: '',
      Description: '',
      MediaStreamId: '',
      MediaStreamName: '',
      MediaStreamType: '',
      VideoFormat: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/flows/:flowArn/mediaStreams');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows/:flowArn/mediaStreams',
  headers: {'content-type': 'application/json'},
  data: {
    mediaStreams: [
      {
        Attributes: '',
        ClockRate: '',
        Description: '',
        MediaStreamId: '',
        MediaStreamName: '',
        MediaStreamType: '',
        VideoFormat: ''
      }
    ]
  }
};

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

const url = '{{baseUrl}}/v1/flows/:flowArn/mediaStreams';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"mediaStreams":[{"Attributes":"","ClockRate":"","Description":"","MediaStreamId":"","MediaStreamName":"","MediaStreamType":"","VideoFormat":""}]}'
};

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}}/v1/flows/:flowArn/mediaStreams',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "mediaStreams": [\n    {\n      "Attributes": "",\n      "ClockRate": "",\n      "Description": "",\n      "MediaStreamId": "",\n      "MediaStreamName": "",\n      "MediaStreamType": "",\n      "VideoFormat": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/mediaStreams")
  .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/v1/flows/:flowArn/mediaStreams',
  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({
  mediaStreams: [
    {
      Attributes: '',
      ClockRate: '',
      Description: '',
      MediaStreamId: '',
      MediaStreamName: '',
      MediaStreamType: '',
      VideoFormat: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows/:flowArn/mediaStreams',
  headers: {'content-type': 'application/json'},
  body: {
    mediaStreams: [
      {
        Attributes: '',
        ClockRate: '',
        Description: '',
        MediaStreamId: '',
        MediaStreamName: '',
        MediaStreamType: '',
        VideoFormat: ''
      }
    ]
  },
  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}}/v1/flows/:flowArn/mediaStreams');

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

req.type('json');
req.send({
  mediaStreams: [
    {
      Attributes: '',
      ClockRate: '',
      Description: '',
      MediaStreamId: '',
      MediaStreamName: '',
      MediaStreamType: '',
      VideoFormat: ''
    }
  ]
});

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}}/v1/flows/:flowArn/mediaStreams',
  headers: {'content-type': 'application/json'},
  data: {
    mediaStreams: [
      {
        Attributes: '',
        ClockRate: '',
        Description: '',
        MediaStreamId: '',
        MediaStreamName: '',
        MediaStreamType: '',
        VideoFormat: ''
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/v1/flows/:flowArn/mediaStreams';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"mediaStreams":[{"Attributes":"","ClockRate":"","Description":"","MediaStreamId":"","MediaStreamName":"","MediaStreamType":"","VideoFormat":""}]}'
};

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 = @{ @"mediaStreams": @[ @{ @"Attributes": @"", @"ClockRate": @"", @"Description": @"", @"MediaStreamId": @"", @"MediaStreamName": @"", @"MediaStreamType": @"", @"VideoFormat": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/:flowArn/mediaStreams"]
                                                       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}}/v1/flows/:flowArn/mediaStreams" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1/flows/:flowArn/mediaStreams",
  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([
    'mediaStreams' => [
        [
                'Attributes' => '',
                'ClockRate' => '',
                'Description' => '',
                'MediaStreamId' => '',
                'MediaStreamName' => '',
                'MediaStreamType' => '',
                'VideoFormat' => ''
        ]
    ]
  ]),
  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}}/v1/flows/:flowArn/mediaStreams', [
  'body' => '{
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/mediaStreams');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'mediaStreams' => [
    [
        'Attributes' => '',
        'ClockRate' => '',
        'Description' => '',
        'MediaStreamId' => '',
        'MediaStreamName' => '',
        'MediaStreamType' => '',
        'VideoFormat' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'mediaStreams' => [
    [
        'Attributes' => '',
        'ClockRate' => '',
        'Description' => '',
        'MediaStreamId' => '',
        'MediaStreamName' => '',
        'MediaStreamType' => '',
        'VideoFormat' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/mediaStreams');
$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}}/v1/flows/:flowArn/mediaStreams' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/mediaStreams' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1/flows/:flowArn/mediaStreams", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/mediaStreams"

payload = { "mediaStreams": [
        {
            "Attributes": "",
            "ClockRate": "",
            "Description": "",
            "MediaStreamId": "",
            "MediaStreamName": "",
            "MediaStreamType": "",
            "VideoFormat": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/mediaStreams"

payload <- "{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/mediaStreams")

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  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/flows/:flowArn/mediaStreams') do |req|
  req.body = "{\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"mediaStreams": (
            json!({
                "Attributes": "",
                "ClockRate": "",
                "Description": "",
                "MediaStreamId": "",
                "MediaStreamName": "",
                "MediaStreamType": "",
                "VideoFormat": ""
            })
        )});

    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}}/v1/flows/:flowArn/mediaStreams \
  --header 'content-type: application/json' \
  --data '{
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ]
}'

echo '{
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/flows/:flowArn/mediaStreams \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "mediaStreams": [\n    {\n      "Attributes": "",\n      "ClockRate": "",\n      "Description": "",\n      "MediaStreamId": "",\n      "MediaStreamName": "",\n      "MediaStreamType": "",\n      "VideoFormat": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/mediaStreams

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["mediaStreams": [
    [
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/mediaStreams")! 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 AddFlowOutputs

{{baseUrl}}/v1/flows/:flowArn/outputs

QUERY PARAMS

flowArn

BODY json

{
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/outputs");

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  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/flows/:flowArn/outputs" {:content-type :json
                                                                      :form-params {:outputs [{:CidrAllowList ""
                                                                                               :Description ""
                                                                                               :Destination ""
                                                                                               :Encryption ""
                                                                                               :MaxLatency ""
                                                                                               :MediaStreamOutputConfigurations ""
                                                                                               :MinLatency ""
                                                                                               :Name ""
                                                                                               :Port ""
                                                                                               :Protocol ""
                                                                                               :RemoteId ""
                                                                                               :SenderControlPort ""
                                                                                               :SmoothingLatency ""
                                                                                               :StreamId ""
                                                                                               :VpcInterfaceAttachment ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/outputs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/flows/:flowArn/outputs"),
    Content = new StringContent("{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/:flowArn/outputs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/outputs"

	payload := strings.NewReader("{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/flows/:flowArn/outputs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 426

{
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/flows/:flowArn/outputs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/outputs"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/outputs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/flows/:flowArn/outputs")
  .header("content-type", "application/json")
  .body("{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  outputs: [
    {
      CidrAllowList: '',
      Description: '',
      Destination: '',
      Encryption: '',
      MaxLatency: '',
      MediaStreamOutputConfigurations: '',
      MinLatency: '',
      Name: '',
      Port: '',
      Protocol: '',
      RemoteId: '',
      SenderControlPort: '',
      SmoothingLatency: '',
      StreamId: '',
      VpcInterfaceAttachment: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/flows/:flowArn/outputs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows/:flowArn/outputs',
  headers: {'content-type': 'application/json'},
  data: {
    outputs: [
      {
        CidrAllowList: '',
        Description: '',
        Destination: '',
        Encryption: '',
        MaxLatency: '',
        MediaStreamOutputConfigurations: '',
        MinLatency: '',
        Name: '',
        Port: '',
        Protocol: '',
        RemoteId: '',
        SenderControlPort: '',
        SmoothingLatency: '',
        StreamId: '',
        VpcInterfaceAttachment: ''
      }
    ]
  }
};

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

const url = '{{baseUrl}}/v1/flows/:flowArn/outputs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"outputs":[{"CidrAllowList":"","Description":"","Destination":"","Encryption":"","MaxLatency":"","MediaStreamOutputConfigurations":"","MinLatency":"","Name":"","Port":"","Protocol":"","RemoteId":"","SenderControlPort":"","SmoothingLatency":"","StreamId":"","VpcInterfaceAttachment":""}]}'
};

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}}/v1/flows/:flowArn/outputs',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "outputs": [\n    {\n      "CidrAllowList": "",\n      "Description": "",\n      "Destination": "",\n      "Encryption": "",\n      "MaxLatency": "",\n      "MediaStreamOutputConfigurations": "",\n      "MinLatency": "",\n      "Name": "",\n      "Port": "",\n      "Protocol": "",\n      "RemoteId": "",\n      "SenderControlPort": "",\n      "SmoothingLatency": "",\n      "StreamId": "",\n      "VpcInterfaceAttachment": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/outputs")
  .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/v1/flows/:flowArn/outputs',
  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({
  outputs: [
    {
      CidrAllowList: '',
      Description: '',
      Destination: '',
      Encryption: '',
      MaxLatency: '',
      MediaStreamOutputConfigurations: '',
      MinLatency: '',
      Name: '',
      Port: '',
      Protocol: '',
      RemoteId: '',
      SenderControlPort: '',
      SmoothingLatency: '',
      StreamId: '',
      VpcInterfaceAttachment: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows/:flowArn/outputs',
  headers: {'content-type': 'application/json'},
  body: {
    outputs: [
      {
        CidrAllowList: '',
        Description: '',
        Destination: '',
        Encryption: '',
        MaxLatency: '',
        MediaStreamOutputConfigurations: '',
        MinLatency: '',
        Name: '',
        Port: '',
        Protocol: '',
        RemoteId: '',
        SenderControlPort: '',
        SmoothingLatency: '',
        StreamId: '',
        VpcInterfaceAttachment: ''
      }
    ]
  },
  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}}/v1/flows/:flowArn/outputs');

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

req.type('json');
req.send({
  outputs: [
    {
      CidrAllowList: '',
      Description: '',
      Destination: '',
      Encryption: '',
      MaxLatency: '',
      MediaStreamOutputConfigurations: '',
      MinLatency: '',
      Name: '',
      Port: '',
      Protocol: '',
      RemoteId: '',
      SenderControlPort: '',
      SmoothingLatency: '',
      StreamId: '',
      VpcInterfaceAttachment: ''
    }
  ]
});

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}}/v1/flows/:flowArn/outputs',
  headers: {'content-type': 'application/json'},
  data: {
    outputs: [
      {
        CidrAllowList: '',
        Description: '',
        Destination: '',
        Encryption: '',
        MaxLatency: '',
        MediaStreamOutputConfigurations: '',
        MinLatency: '',
        Name: '',
        Port: '',
        Protocol: '',
        RemoteId: '',
        SenderControlPort: '',
        SmoothingLatency: '',
        StreamId: '',
        VpcInterfaceAttachment: ''
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/v1/flows/:flowArn/outputs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"outputs":[{"CidrAllowList":"","Description":"","Destination":"","Encryption":"","MaxLatency":"","MediaStreamOutputConfigurations":"","MinLatency":"","Name":"","Port":"","Protocol":"","RemoteId":"","SenderControlPort":"","SmoothingLatency":"","StreamId":"","VpcInterfaceAttachment":""}]}'
};

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 = @{ @"outputs": @[ @{ @"CidrAllowList": @"", @"Description": @"", @"Destination": @"", @"Encryption": @"", @"MaxLatency": @"", @"MediaStreamOutputConfigurations": @"", @"MinLatency": @"", @"Name": @"", @"Port": @"", @"Protocol": @"", @"RemoteId": @"", @"SenderControlPort": @"", @"SmoothingLatency": @"", @"StreamId": @"", @"VpcInterfaceAttachment": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/:flowArn/outputs"]
                                                       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}}/v1/flows/:flowArn/outputs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1/flows/:flowArn/outputs",
  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([
    'outputs' => [
        [
                'CidrAllowList' => '',
                'Description' => '',
                'Destination' => '',
                'Encryption' => '',
                'MaxLatency' => '',
                'MediaStreamOutputConfigurations' => '',
                'MinLatency' => '',
                'Name' => '',
                'Port' => '',
                'Protocol' => '',
                'RemoteId' => '',
                'SenderControlPort' => '',
                'SmoothingLatency' => '',
                'StreamId' => '',
                'VpcInterfaceAttachment' => ''
        ]
    ]
  ]),
  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}}/v1/flows/:flowArn/outputs', [
  'body' => '{
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/outputs');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'outputs' => [
    [
        'CidrAllowList' => '',
        'Description' => '',
        'Destination' => '',
        'Encryption' => '',
        'MaxLatency' => '',
        'MediaStreamOutputConfigurations' => '',
        'MinLatency' => '',
        'Name' => '',
        'Port' => '',
        'Protocol' => '',
        'RemoteId' => '',
        'SenderControlPort' => '',
        'SmoothingLatency' => '',
        'StreamId' => '',
        'VpcInterfaceAttachment' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'outputs' => [
    [
        'CidrAllowList' => '',
        'Description' => '',
        'Destination' => '',
        'Encryption' => '',
        'MaxLatency' => '',
        'MediaStreamOutputConfigurations' => '',
        'MinLatency' => '',
        'Name' => '',
        'Port' => '',
        'Protocol' => '',
        'RemoteId' => '',
        'SenderControlPort' => '',
        'SmoothingLatency' => '',
        'StreamId' => '',
        'VpcInterfaceAttachment' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/outputs');
$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}}/v1/flows/:flowArn/outputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/outputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1/flows/:flowArn/outputs", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/outputs"

payload = { "outputs": [
        {
            "CidrAllowList": "",
            "Description": "",
            "Destination": "",
            "Encryption": "",
            "MaxLatency": "",
            "MediaStreamOutputConfigurations": "",
            "MinLatency": "",
            "Name": "",
            "Port": "",
            "Protocol": "",
            "RemoteId": "",
            "SenderControlPort": "",
            "SmoothingLatency": "",
            "StreamId": "",
            "VpcInterfaceAttachment": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/outputs"

payload <- "{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/outputs")

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  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/flows/:flowArn/outputs') do |req|
  req.body = "{\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"outputs": (
            json!({
                "CidrAllowList": "",
                "Description": "",
                "Destination": "",
                "Encryption": "",
                "MaxLatency": "",
                "MediaStreamOutputConfigurations": "",
                "MinLatency": "",
                "Name": "",
                "Port": "",
                "Protocol": "",
                "RemoteId": "",
                "SenderControlPort": "",
                "SmoothingLatency": "",
                "StreamId": "",
                "VpcInterfaceAttachment": ""
            })
        )});

    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}}/v1/flows/:flowArn/outputs \
  --header 'content-type: application/json' \
  --data '{
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ]
}'

echo '{
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/flows/:flowArn/outputs \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "outputs": [\n    {\n      "CidrAllowList": "",\n      "Description": "",\n      "Destination": "",\n      "Encryption": "",\n      "MaxLatency": "",\n      "MediaStreamOutputConfigurations": "",\n      "MinLatency": "",\n      "Name": "",\n      "Port": "",\n      "Protocol": "",\n      "RemoteId": "",\n      "SenderControlPort": "",\n      "SmoothingLatency": "",\n      "StreamId": "",\n      "VpcInterfaceAttachment": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/outputs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["outputs": [
    [
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/outputs")! 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 AddFlowSources

{{baseUrl}}/v1/flows/:flowArn/source

QUERY PARAMS

flowArn

BODY json

{
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/source");

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  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/flows/:flowArn/source" {:content-type :json
                                                                     :form-params {:sources [{:Decryption ""
                                                                                              :Description ""
                                                                                              :EntitlementArn ""
                                                                                              :IngestPort ""
                                                                                              :MaxBitrate ""
                                                                                              :MaxLatency ""
                                                                                              :MaxSyncBuffer ""
                                                                                              :MediaStreamSourceConfigurations ""
                                                                                              :MinLatency ""
                                                                                              :Name ""
                                                                                              :Protocol ""
                                                                                              :SenderControlPort ""
                                                                                              :SenderIpAddress ""
                                                                                              :SourceListenerAddress ""
                                                                                              :SourceListenerPort ""
                                                                                              :StreamId ""
                                                                                              :VpcInterfaceName ""
                                                                                              :WhitelistCidr ""
                                                                                              :GatewayBridgeSource ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/source"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/flows/:flowArn/source"),
    Content = new StringContent("{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/:flowArn/source");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/source"

	payload := strings.NewReader("{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/flows/:flowArn/source HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 557

{
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/flows/:flowArn/source")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/source"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/source")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/flows/:flowArn/source")
  .header("content-type", "application/json")
  .body("{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  sources: [
    {
      Decryption: '',
      Description: '',
      EntitlementArn: '',
      IngestPort: '',
      MaxBitrate: '',
      MaxLatency: '',
      MaxSyncBuffer: '',
      MediaStreamSourceConfigurations: '',
      MinLatency: '',
      Name: '',
      Protocol: '',
      SenderControlPort: '',
      SenderIpAddress: '',
      SourceListenerAddress: '',
      SourceListenerPort: '',
      StreamId: '',
      VpcInterfaceName: '',
      WhitelistCidr: '',
      GatewayBridgeSource: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/flows/:flowArn/source');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows/:flowArn/source',
  headers: {'content-type': 'application/json'},
  data: {
    sources: [
      {
        Decryption: '',
        Description: '',
        EntitlementArn: '',
        IngestPort: '',
        MaxBitrate: '',
        MaxLatency: '',
        MaxSyncBuffer: '',
        MediaStreamSourceConfigurations: '',
        MinLatency: '',
        Name: '',
        Protocol: '',
        SenderControlPort: '',
        SenderIpAddress: '',
        SourceListenerAddress: '',
        SourceListenerPort: '',
        StreamId: '',
        VpcInterfaceName: '',
        WhitelistCidr: '',
        GatewayBridgeSource: ''
      }
    ]
  }
};

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

const url = '{{baseUrl}}/v1/flows/:flowArn/source';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"sources":[{"Decryption":"","Description":"","EntitlementArn":"","IngestPort":"","MaxBitrate":"","MaxLatency":"","MaxSyncBuffer":"","MediaStreamSourceConfigurations":"","MinLatency":"","Name":"","Protocol":"","SenderControlPort":"","SenderIpAddress":"","SourceListenerAddress":"","SourceListenerPort":"","StreamId":"","VpcInterfaceName":"","WhitelistCidr":"","GatewayBridgeSource":""}]}'
};

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}}/v1/flows/:flowArn/source',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "sources": [\n    {\n      "Decryption": "",\n      "Description": "",\n      "EntitlementArn": "",\n      "IngestPort": "",\n      "MaxBitrate": "",\n      "MaxLatency": "",\n      "MaxSyncBuffer": "",\n      "MediaStreamSourceConfigurations": "",\n      "MinLatency": "",\n      "Name": "",\n      "Protocol": "",\n      "SenderControlPort": "",\n      "SenderIpAddress": "",\n      "SourceListenerAddress": "",\n      "SourceListenerPort": "",\n      "StreamId": "",\n      "VpcInterfaceName": "",\n      "WhitelistCidr": "",\n      "GatewayBridgeSource": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/source")
  .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/v1/flows/:flowArn/source',
  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({
  sources: [
    {
      Decryption: '',
      Description: '',
      EntitlementArn: '',
      IngestPort: '',
      MaxBitrate: '',
      MaxLatency: '',
      MaxSyncBuffer: '',
      MediaStreamSourceConfigurations: '',
      MinLatency: '',
      Name: '',
      Protocol: '',
      SenderControlPort: '',
      SenderIpAddress: '',
      SourceListenerAddress: '',
      SourceListenerPort: '',
      StreamId: '',
      VpcInterfaceName: '',
      WhitelistCidr: '',
      GatewayBridgeSource: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows/:flowArn/source',
  headers: {'content-type': 'application/json'},
  body: {
    sources: [
      {
        Decryption: '',
        Description: '',
        EntitlementArn: '',
        IngestPort: '',
        MaxBitrate: '',
        MaxLatency: '',
        MaxSyncBuffer: '',
        MediaStreamSourceConfigurations: '',
        MinLatency: '',
        Name: '',
        Protocol: '',
        SenderControlPort: '',
        SenderIpAddress: '',
        SourceListenerAddress: '',
        SourceListenerPort: '',
        StreamId: '',
        VpcInterfaceName: '',
        WhitelistCidr: '',
        GatewayBridgeSource: ''
      }
    ]
  },
  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}}/v1/flows/:flowArn/source');

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

req.type('json');
req.send({
  sources: [
    {
      Decryption: '',
      Description: '',
      EntitlementArn: '',
      IngestPort: '',
      MaxBitrate: '',
      MaxLatency: '',
      MaxSyncBuffer: '',
      MediaStreamSourceConfigurations: '',
      MinLatency: '',
      Name: '',
      Protocol: '',
      SenderControlPort: '',
      SenderIpAddress: '',
      SourceListenerAddress: '',
      SourceListenerPort: '',
      StreamId: '',
      VpcInterfaceName: '',
      WhitelistCidr: '',
      GatewayBridgeSource: ''
    }
  ]
});

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}}/v1/flows/:flowArn/source',
  headers: {'content-type': 'application/json'},
  data: {
    sources: [
      {
        Decryption: '',
        Description: '',
        EntitlementArn: '',
        IngestPort: '',
        MaxBitrate: '',
        MaxLatency: '',
        MaxSyncBuffer: '',
        MediaStreamSourceConfigurations: '',
        MinLatency: '',
        Name: '',
        Protocol: '',
        SenderControlPort: '',
        SenderIpAddress: '',
        SourceListenerAddress: '',
        SourceListenerPort: '',
        StreamId: '',
        VpcInterfaceName: '',
        WhitelistCidr: '',
        GatewayBridgeSource: ''
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/v1/flows/:flowArn/source';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"sources":[{"Decryption":"","Description":"","EntitlementArn":"","IngestPort":"","MaxBitrate":"","MaxLatency":"","MaxSyncBuffer":"","MediaStreamSourceConfigurations":"","MinLatency":"","Name":"","Protocol":"","SenderControlPort":"","SenderIpAddress":"","SourceListenerAddress":"","SourceListenerPort":"","StreamId":"","VpcInterfaceName":"","WhitelistCidr":"","GatewayBridgeSource":""}]}'
};

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 = @{ @"sources": @[ @{ @"Decryption": @"", @"Description": @"", @"EntitlementArn": @"", @"IngestPort": @"", @"MaxBitrate": @"", @"MaxLatency": @"", @"MaxSyncBuffer": @"", @"MediaStreamSourceConfigurations": @"", @"MinLatency": @"", @"Name": @"", @"Protocol": @"", @"SenderControlPort": @"", @"SenderIpAddress": @"", @"SourceListenerAddress": @"", @"SourceListenerPort": @"", @"StreamId": @"", @"VpcInterfaceName": @"", @"WhitelistCidr": @"", @"GatewayBridgeSource": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/:flowArn/source"]
                                                       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}}/v1/flows/:flowArn/source" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1/flows/:flowArn/source",
  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([
    'sources' => [
        [
                'Decryption' => '',
                'Description' => '',
                'EntitlementArn' => '',
                'IngestPort' => '',
                'MaxBitrate' => '',
                'MaxLatency' => '',
                'MaxSyncBuffer' => '',
                'MediaStreamSourceConfigurations' => '',
                'MinLatency' => '',
                'Name' => '',
                'Protocol' => '',
                'SenderControlPort' => '',
                'SenderIpAddress' => '',
                'SourceListenerAddress' => '',
                'SourceListenerPort' => '',
                'StreamId' => '',
                'VpcInterfaceName' => '',
                'WhitelistCidr' => '',
                'GatewayBridgeSource' => ''
        ]
    ]
  ]),
  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}}/v1/flows/:flowArn/source', [
  'body' => '{
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/source');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'sources' => [
    [
        'Decryption' => '',
        'Description' => '',
        'EntitlementArn' => '',
        'IngestPort' => '',
        'MaxBitrate' => '',
        'MaxLatency' => '',
        'MaxSyncBuffer' => '',
        'MediaStreamSourceConfigurations' => '',
        'MinLatency' => '',
        'Name' => '',
        'Protocol' => '',
        'SenderControlPort' => '',
        'SenderIpAddress' => '',
        'SourceListenerAddress' => '',
        'SourceListenerPort' => '',
        'StreamId' => '',
        'VpcInterfaceName' => '',
        'WhitelistCidr' => '',
        'GatewayBridgeSource' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'sources' => [
    [
        'Decryption' => '',
        'Description' => '',
        'EntitlementArn' => '',
        'IngestPort' => '',
        'MaxBitrate' => '',
        'MaxLatency' => '',
        'MaxSyncBuffer' => '',
        'MediaStreamSourceConfigurations' => '',
        'MinLatency' => '',
        'Name' => '',
        'Protocol' => '',
        'SenderControlPort' => '',
        'SenderIpAddress' => '',
        'SourceListenerAddress' => '',
        'SourceListenerPort' => '',
        'StreamId' => '',
        'VpcInterfaceName' => '',
        'WhitelistCidr' => '',
        'GatewayBridgeSource' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/source');
$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}}/v1/flows/:flowArn/source' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/source' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1/flows/:flowArn/source", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/source"

payload = { "sources": [
        {
            "Decryption": "",
            "Description": "",
            "EntitlementArn": "",
            "IngestPort": "",
            "MaxBitrate": "",
            "MaxLatency": "",
            "MaxSyncBuffer": "",
            "MediaStreamSourceConfigurations": "",
            "MinLatency": "",
            "Name": "",
            "Protocol": "",
            "SenderControlPort": "",
            "SenderIpAddress": "",
            "SourceListenerAddress": "",
            "SourceListenerPort": "",
            "StreamId": "",
            "VpcInterfaceName": "",
            "WhitelistCidr": "",
            "GatewayBridgeSource": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/source"

payload <- "{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/source")

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  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/flows/:flowArn/source') do |req|
  req.body = "{\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"sources": (
            json!({
                "Decryption": "",
                "Description": "",
                "EntitlementArn": "",
                "IngestPort": "",
                "MaxBitrate": "",
                "MaxLatency": "",
                "MaxSyncBuffer": "",
                "MediaStreamSourceConfigurations": "",
                "MinLatency": "",
                "Name": "",
                "Protocol": "",
                "SenderControlPort": "",
                "SenderIpAddress": "",
                "SourceListenerAddress": "",
                "SourceListenerPort": "",
                "StreamId": "",
                "VpcInterfaceName": "",
                "WhitelistCidr": "",
                "GatewayBridgeSource": ""
            })
        )});

    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}}/v1/flows/:flowArn/source \
  --header 'content-type: application/json' \
  --data '{
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ]
}'

echo '{
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/flows/:flowArn/source \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "sources": [\n    {\n      "Decryption": "",\n      "Description": "",\n      "EntitlementArn": "",\n      "IngestPort": "",\n      "MaxBitrate": "",\n      "MaxLatency": "",\n      "MaxSyncBuffer": "",\n      "MediaStreamSourceConfigurations": "",\n      "MinLatency": "",\n      "Name": "",\n      "Protocol": "",\n      "SenderControlPort": "",\n      "SenderIpAddress": "",\n      "SourceListenerAddress": "",\n      "SourceListenerPort": "",\n      "StreamId": "",\n      "VpcInterfaceName": "",\n      "WhitelistCidr": "",\n      "GatewayBridgeSource": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/source

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["sources": [
    [
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/source")! 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 AddFlowVpcInterfaces

{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces

QUERY PARAMS

flowArn

BODY json

{
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces");

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  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces" {:content-type :json
                                                                            :form-params {:vpcInterfaces [{:Name ""
                                                                                                           :NetworkInterfaceType ""
                                                                                                           :RoleArn ""
                                                                                                           :SecurityGroupIds ""
                                                                                                           :SubnetId ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces"),
    Content = new StringContent("{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces"

	payload := strings.NewReader("{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/flows/:flowArn/vpcInterfaces HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 164

{
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces")
  .header("content-type", "application/json")
  .body("{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  vpcInterfaces: [
    {
      Name: '',
      NetworkInterfaceType: '',
      RoleArn: '',
      SecurityGroupIds: '',
      SubnetId: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces',
  headers: {'content-type': 'application/json'},
  data: {
    vpcInterfaces: [
      {
        Name: '',
        NetworkInterfaceType: '',
        RoleArn: '',
        SecurityGroupIds: '',
        SubnetId: ''
      }
    ]
  }
};

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

const url = '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"vpcInterfaces":[{"Name":"","NetworkInterfaceType":"","RoleArn":"","SecurityGroupIds":"","SubnetId":""}]}'
};

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}}/v1/flows/:flowArn/vpcInterfaces',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "vpcInterfaces": [\n    {\n      "Name": "",\n      "NetworkInterfaceType": "",\n      "RoleArn": "",\n      "SecurityGroupIds": "",\n      "SubnetId": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces")
  .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/v1/flows/:flowArn/vpcInterfaces',
  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({
  vpcInterfaces: [
    {
      Name: '',
      NetworkInterfaceType: '',
      RoleArn: '',
      SecurityGroupIds: '',
      SubnetId: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces',
  headers: {'content-type': 'application/json'},
  body: {
    vpcInterfaces: [
      {
        Name: '',
        NetworkInterfaceType: '',
        RoleArn: '',
        SecurityGroupIds: '',
        SubnetId: ''
      }
    ]
  },
  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}}/v1/flows/:flowArn/vpcInterfaces');

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

req.type('json');
req.send({
  vpcInterfaces: [
    {
      Name: '',
      NetworkInterfaceType: '',
      RoleArn: '',
      SecurityGroupIds: '',
      SubnetId: ''
    }
  ]
});

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}}/v1/flows/:flowArn/vpcInterfaces',
  headers: {'content-type': 'application/json'},
  data: {
    vpcInterfaces: [
      {
        Name: '',
        NetworkInterfaceType: '',
        RoleArn: '',
        SecurityGroupIds: '',
        SubnetId: ''
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"vpcInterfaces":[{"Name":"","NetworkInterfaceType":"","RoleArn":"","SecurityGroupIds":"","SubnetId":""}]}'
};

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 = @{ @"vpcInterfaces": @[ @{ @"Name": @"", @"NetworkInterfaceType": @"", @"RoleArn": @"", @"SecurityGroupIds": @"", @"SubnetId": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces"]
                                                       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}}/v1/flows/:flowArn/vpcInterfaces" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces",
  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([
    'vpcInterfaces' => [
        [
                'Name' => '',
                'NetworkInterfaceType' => '',
                'RoleArn' => '',
                'SecurityGroupIds' => '',
                'SubnetId' => ''
        ]
    ]
  ]),
  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}}/v1/flows/:flowArn/vpcInterfaces', [
  'body' => '{
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'vpcInterfaces' => [
    [
        'Name' => '',
        'NetworkInterfaceType' => '',
        'RoleArn' => '',
        'SecurityGroupIds' => '',
        'SubnetId' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'vpcInterfaces' => [
    [
        'Name' => '',
        'NetworkInterfaceType' => '',
        'RoleArn' => '',
        'SecurityGroupIds' => '',
        'SubnetId' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces');
$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}}/v1/flows/:flowArn/vpcInterfaces' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1/flows/:flowArn/vpcInterfaces", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces"

payload = { "vpcInterfaces": [
        {
            "Name": "",
            "NetworkInterfaceType": "",
            "RoleArn": "",
            "SecurityGroupIds": "",
            "SubnetId": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces"

payload <- "{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces")

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  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/flows/:flowArn/vpcInterfaces') do |req|
  req.body = "{\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"vpcInterfaces": (
            json!({
                "Name": "",
                "NetworkInterfaceType": "",
                "RoleArn": "",
                "SecurityGroupIds": "",
                "SubnetId": ""
            })
        )});

    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}}/v1/flows/:flowArn/vpcInterfaces \
  --header 'content-type: application/json' \
  --data '{
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ]
}'

echo '{
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/flows/:flowArn/vpcInterfaces \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "vpcInterfaces": [\n    {\n      "Name": "",\n      "NetworkInterfaceType": "",\n      "RoleArn": "",\n      "SecurityGroupIds": "",\n      "SubnetId": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/vpcInterfaces

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["vpcInterfaces": [
    [
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces")! 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 CreateBridge

{{baseUrl}}/v1/bridges

BODY json

{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "name": "",
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ],
  "placementArn": "",
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/bridges" {:content-type :json
                                                       :form-params {:egressGatewayBridge {:MaxBitrate ""}
                                                                     :ingressGatewayBridge {:MaxBitrate ""
                                                                                            :MaxOutputs ""}
                                                                     :name ""
                                                                     :outputs [{:NetworkOutput ""}]
                                                                     :placementArn ""
                                                                     :sourceFailoverConfig {:FailoverMode ""
                                                                                            :RecoveryWindow ""
                                                                                            :SourcePriority ""
                                                                                            :State ""}
                                                                     :sources [{:FlowSource ""
                                                                                :NetworkSource ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/bridges"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/bridges"),
    Content = new StringContent("{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/bridges");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/bridges"

	payload := strings.NewReader("{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/bridges HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 432

{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "name": "",
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ],
  "placementArn": "",
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/bridges")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/bridges"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/bridges")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/bridges")
  .header("content-type", "application/json")
  .body("{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  egressGatewayBridge: {
    MaxBitrate: ''
  },
  ingressGatewayBridge: {
    MaxBitrate: '',
    MaxOutputs: ''
  },
  name: '',
  outputs: [
    {
      NetworkOutput: ''
    }
  ],
  placementArn: '',
  sourceFailoverConfig: {
    FailoverMode: '',
    RecoveryWindow: '',
    SourcePriority: '',
    State: ''
  },
  sources: [
    {
      FlowSource: '',
      NetworkSource: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/bridges',
  headers: {'content-type': 'application/json'},
  data: {
    egressGatewayBridge: {MaxBitrate: ''},
    ingressGatewayBridge: {MaxBitrate: '', MaxOutputs: ''},
    name: '',
    outputs: [{NetworkOutput: ''}],
    placementArn: '',
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
    sources: [{FlowSource: '', NetworkSource: ''}]
  }
};

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

const url = '{{baseUrl}}/v1/bridges';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"egressGatewayBridge":{"MaxBitrate":""},"ingressGatewayBridge":{"MaxBitrate":"","MaxOutputs":""},"name":"","outputs":[{"NetworkOutput":""}],"placementArn":"","sourceFailoverConfig":{"FailoverMode":"","RecoveryWindow":"","SourcePriority":"","State":""},"sources":[{"FlowSource":"","NetworkSource":""}]}'
};

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}}/v1/bridges',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "egressGatewayBridge": {\n    "MaxBitrate": ""\n  },\n  "ingressGatewayBridge": {\n    "MaxBitrate": "",\n    "MaxOutputs": ""\n  },\n  "name": "",\n  "outputs": [\n    {\n      "NetworkOutput": ""\n    }\n  ],\n  "placementArn": "",\n  "sourceFailoverConfig": {\n    "FailoverMode": "",\n    "RecoveryWindow": "",\n    "SourcePriority": "",\n    "State": ""\n  },\n  "sources": [\n    {\n      "FlowSource": "",\n      "NetworkSource": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/bridges")
  .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/v1/bridges',
  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({
  egressGatewayBridge: {MaxBitrate: ''},
  ingressGatewayBridge: {MaxBitrate: '', MaxOutputs: ''},
  name: '',
  outputs: [{NetworkOutput: ''}],
  placementArn: '',
  sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
  sources: [{FlowSource: '', NetworkSource: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/bridges',
  headers: {'content-type': 'application/json'},
  body: {
    egressGatewayBridge: {MaxBitrate: ''},
    ingressGatewayBridge: {MaxBitrate: '', MaxOutputs: ''},
    name: '',
    outputs: [{NetworkOutput: ''}],
    placementArn: '',
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
    sources: [{FlowSource: '', NetworkSource: ''}]
  },
  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}}/v1/bridges');

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

req.type('json');
req.send({
  egressGatewayBridge: {
    MaxBitrate: ''
  },
  ingressGatewayBridge: {
    MaxBitrate: '',
    MaxOutputs: ''
  },
  name: '',
  outputs: [
    {
      NetworkOutput: ''
    }
  ],
  placementArn: '',
  sourceFailoverConfig: {
    FailoverMode: '',
    RecoveryWindow: '',
    SourcePriority: '',
    State: ''
  },
  sources: [
    {
      FlowSource: '',
      NetworkSource: ''
    }
  ]
});

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}}/v1/bridges',
  headers: {'content-type': 'application/json'},
  data: {
    egressGatewayBridge: {MaxBitrate: ''},
    ingressGatewayBridge: {MaxBitrate: '', MaxOutputs: ''},
    name: '',
    outputs: [{NetworkOutput: ''}],
    placementArn: '',
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
    sources: [{FlowSource: '', NetworkSource: ''}]
  }
};

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

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

const url = '{{baseUrl}}/v1/bridges';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"egressGatewayBridge":{"MaxBitrate":""},"ingressGatewayBridge":{"MaxBitrate":"","MaxOutputs":""},"name":"","outputs":[{"NetworkOutput":""}],"placementArn":"","sourceFailoverConfig":{"FailoverMode":"","RecoveryWindow":"","SourcePriority":"","State":""},"sources":[{"FlowSource":"","NetworkSource":""}]}'
};

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 = @{ @"egressGatewayBridge": @{ @"MaxBitrate": @"" },
                              @"ingressGatewayBridge": @{ @"MaxBitrate": @"", @"MaxOutputs": @"" },
                              @"name": @"",
                              @"outputs": @[ @{ @"NetworkOutput": @"" } ],
                              @"placementArn": @"",
                              @"sourceFailoverConfig": @{ @"FailoverMode": @"", @"RecoveryWindow": @"", @"SourcePriority": @"", @"State": @"" },
                              @"sources": @[ @{ @"FlowSource": @"", @"NetworkSource": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/bridges"]
                                                       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}}/v1/bridges" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1/bridges",
  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([
    'egressGatewayBridge' => [
        'MaxBitrate' => ''
    ],
    'ingressGatewayBridge' => [
        'MaxBitrate' => '',
        'MaxOutputs' => ''
    ],
    'name' => '',
    'outputs' => [
        [
                'NetworkOutput' => ''
        ]
    ],
    'placementArn' => '',
    'sourceFailoverConfig' => [
        'FailoverMode' => '',
        'RecoveryWindow' => '',
        'SourcePriority' => '',
        'State' => ''
    ],
    'sources' => [
        [
                'FlowSource' => '',
                'NetworkSource' => ''
        ]
    ]
  ]),
  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}}/v1/bridges', [
  'body' => '{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "name": "",
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ],
  "placementArn": "",
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'egressGatewayBridge' => [
    'MaxBitrate' => ''
  ],
  'ingressGatewayBridge' => [
    'MaxBitrate' => '',
    'MaxOutputs' => ''
  ],
  'name' => '',
  'outputs' => [
    [
        'NetworkOutput' => ''
    ]
  ],
  'placementArn' => '',
  'sourceFailoverConfig' => [
    'FailoverMode' => '',
    'RecoveryWindow' => '',
    'SourcePriority' => '',
    'State' => ''
  ],
  'sources' => [
    [
        'FlowSource' => '',
        'NetworkSource' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'egressGatewayBridge' => [
    'MaxBitrate' => ''
  ],
  'ingressGatewayBridge' => [
    'MaxBitrate' => '',
    'MaxOutputs' => ''
  ],
  'name' => '',
  'outputs' => [
    [
        'NetworkOutput' => ''
    ]
  ],
  'placementArn' => '',
  'sourceFailoverConfig' => [
    'FailoverMode' => '',
    'RecoveryWindow' => '',
    'SourcePriority' => '',
    'State' => ''
  ],
  'sources' => [
    [
        'FlowSource' => '',
        'NetworkSource' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/bridges');
$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}}/v1/bridges' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "name": "",
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ],
  "placementArn": "",
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/bridges' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "name": "",
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ],
  "placementArn": "",
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/v1/bridges"

payload = {
    "egressGatewayBridge": { "MaxBitrate": "" },
    "ingressGatewayBridge": {
        "MaxBitrate": "",
        "MaxOutputs": ""
    },
    "name": "",
    "outputs": [{ "NetworkOutput": "" }],
    "placementArn": "",
    "sourceFailoverConfig": {
        "FailoverMode": "",
        "RecoveryWindow": "",
        "SourcePriority": "",
        "State": ""
    },
    "sources": [
        {
            "FlowSource": "",
            "NetworkSource": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges"

payload <- "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/bridges")

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  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/bridges') do |req|
  req.body = "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"NetworkOutput\": \"\"\n    }\n  ],\n  \"placementArn\": \"\",\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"FlowSource\": \"\",\n      \"NetworkSource\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "egressGatewayBridge": json!({"MaxBitrate": ""}),
        "ingressGatewayBridge": json!({
            "MaxBitrate": "",
            "MaxOutputs": ""
        }),
        "name": "",
        "outputs": (json!({"NetworkOutput": ""})),
        "placementArn": "",
        "sourceFailoverConfig": json!({
            "FailoverMode": "",
            "RecoveryWindow": "",
            "SourcePriority": "",
            "State": ""
        }),
        "sources": (
            json!({
                "FlowSource": "",
                "NetworkSource": ""
            })
        )
    });

    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}}/v1/bridges \
  --header 'content-type: application/json' \
  --data '{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "name": "",
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ],
  "placementArn": "",
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}'

echo '{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "name": "",
  "outputs": [
    {
      "NetworkOutput": ""
    }
  ],
  "placementArn": "",
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "FlowSource": "",
      "NetworkSource": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/bridges \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "egressGatewayBridge": {\n    "MaxBitrate": ""\n  },\n  "ingressGatewayBridge": {\n    "MaxBitrate": "",\n    "MaxOutputs": ""\n  },\n  "name": "",\n  "outputs": [\n    {\n      "NetworkOutput": ""\n    }\n  ],\n  "placementArn": "",\n  "sourceFailoverConfig": {\n    "FailoverMode": "",\n    "RecoveryWindow": "",\n    "SourcePriority": "",\n    "State": ""\n  },\n  "sources": [\n    {\n      "FlowSource": "",\n      "NetworkSource": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/bridges

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "egressGatewayBridge": ["MaxBitrate": ""],
  "ingressGatewayBridge": [
    "MaxBitrate": "",
    "MaxOutputs": ""
  ],
  "name": "",
  "outputs": [["NetworkOutput": ""]],
  "placementArn": "",
  "sourceFailoverConfig": [
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  ],
  "sources": [
    [
      "FlowSource": "",
      "NetworkSource": ""
    ]
  ]
] as [String : Any]

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

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

{{baseUrl}}/v1/flows

BODY json

{
  "availabilityZone": "",
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ],
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ],
  "name": "",
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ],
  "source": {
    "Decryption": "",
    "Description": "",
    "EntitlementArn": "",
    "IngestPort": "",
    "MaxBitrate": "",
    "MaxLatency": "",
    "MaxSyncBuffer": "",
    "MediaStreamSourceConfigurations": "",
    "MinLatency": "",
    "Name": "",
    "Protocol": "",
    "SenderControlPort": "",
    "SenderIpAddress": "",
    "SourceListenerAddress": "",
    "SourceListenerPort": "",
    "StreamId": "",
    "VpcInterfaceName": "",
    "WhitelistCidr": "",
    "GatewayBridgeSource": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ],
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ],
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartHour": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/flows" {:content-type :json
                                                     :form-params {:availabilityZone ""
                                                                   :entitlements [{:DataTransferSubscriberFeePercent ""
                                                                                   :Description ""
                                                                                   :Encryption ""
                                                                                   :EntitlementStatus ""
                                                                                   :Name ""
                                                                                   :Subscribers ""}]
                                                                   :mediaStreams [{:Attributes ""
                                                                                   :ClockRate ""
                                                                                   :Description ""
                                                                                   :MediaStreamId ""
                                                                                   :MediaStreamName ""
                                                                                   :MediaStreamType ""
                                                                                   :VideoFormat ""}]
                                                                   :name ""
                                                                   :outputs [{:CidrAllowList ""
                                                                              :Description ""
                                                                              :Destination ""
                                                                              :Encryption ""
                                                                              :MaxLatency ""
                                                                              :MediaStreamOutputConfigurations ""
                                                                              :MinLatency ""
                                                                              :Name ""
                                                                              :Port ""
                                                                              :Protocol ""
                                                                              :RemoteId ""
                                                                              :SenderControlPort ""
                                                                              :SmoothingLatency ""
                                                                              :StreamId ""
                                                                              :VpcInterfaceAttachment ""}]
                                                                   :source {:Decryption ""
                                                                            :Description ""
                                                                            :EntitlementArn ""
                                                                            :IngestPort ""
                                                                            :MaxBitrate ""
                                                                            :MaxLatency ""
                                                                            :MaxSyncBuffer ""
                                                                            :MediaStreamSourceConfigurations ""
                                                                            :MinLatency ""
                                                                            :Name ""
                                                                            :Protocol ""
                                                                            :SenderControlPort ""
                                                                            :SenderIpAddress ""
                                                                            :SourceListenerAddress ""
                                                                            :SourceListenerPort ""
                                                                            :StreamId ""
                                                                            :VpcInterfaceName ""
                                                                            :WhitelistCidr ""
                                                                            :GatewayBridgeSource ""}
                                                                   :sourceFailoverConfig {:FailoverMode ""
                                                                                          :RecoveryWindow ""
                                                                                          :SourcePriority ""
                                                                                          :State ""}
                                                                   :sources [{:Decryption ""
                                                                              :Description ""
                                                                              :EntitlementArn ""
                                                                              :IngestPort ""
                                                                              :MaxBitrate ""
                                                                              :MaxLatency ""
                                                                              :MaxSyncBuffer ""
                                                                              :MediaStreamSourceConfigurations ""
                                                                              :MinLatency ""
                                                                              :Name ""
                                                                              :Protocol ""
                                                                              :SenderControlPort ""
                                                                              :SenderIpAddress ""
                                                                              :SourceListenerAddress ""
                                                                              :SourceListenerPort ""
                                                                              :StreamId ""
                                                                              :VpcInterfaceName ""
                                                                              :WhitelistCidr ""
                                                                              :GatewayBridgeSource ""}]
                                                                   :vpcInterfaces [{:Name ""
                                                                                    :NetworkInterfaceType ""
                                                                                    :RoleArn ""
                                                                                    :SecurityGroupIds ""
                                                                                    :SubnetId ""}]
                                                                   :maintenance {:MaintenanceDay ""
                                                                                 :MaintenanceStartHour ""}}})

require "http/client"

url = "{{baseUrl}}/v1/flows"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\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}}/v1/flows"),
    Content = new StringContent("{\n  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\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}}/v1/flows");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/flows"

	payload := strings.NewReader("{\n  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\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/v1/flows HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2316

{
  "availabilityZone": "",
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ],
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ],
  "name": "",
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ],
  "source": {
    "Decryption": "",
    "Description": "",
    "EntitlementArn": "",
    "IngestPort": "",
    "MaxBitrate": "",
    "MaxLatency": "",
    "MaxSyncBuffer": "",
    "MediaStreamSourceConfigurations": "",
    "MinLatency": "",
    "Name": "",
    "Protocol": "",
    "SenderControlPort": "",
    "SenderIpAddress": "",
    "SourceListenerAddress": "",
    "SourceListenerPort": "",
    "StreamId": "",
    "VpcInterfaceName": "",
    "WhitelistCidr": "",
    "GatewayBridgeSource": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ],
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ],
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartHour": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/flows")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\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  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/flows")
  .header("content-type", "application/json")
  .body("{\n  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  availabilityZone: '',
  entitlements: [
    {
      DataTransferSubscriberFeePercent: '',
      Description: '',
      Encryption: '',
      EntitlementStatus: '',
      Name: '',
      Subscribers: ''
    }
  ],
  mediaStreams: [
    {
      Attributes: '',
      ClockRate: '',
      Description: '',
      MediaStreamId: '',
      MediaStreamName: '',
      MediaStreamType: '',
      VideoFormat: ''
    }
  ],
  name: '',
  outputs: [
    {
      CidrAllowList: '',
      Description: '',
      Destination: '',
      Encryption: '',
      MaxLatency: '',
      MediaStreamOutputConfigurations: '',
      MinLatency: '',
      Name: '',
      Port: '',
      Protocol: '',
      RemoteId: '',
      SenderControlPort: '',
      SmoothingLatency: '',
      StreamId: '',
      VpcInterfaceAttachment: ''
    }
  ],
  source: {
    Decryption: '',
    Description: '',
    EntitlementArn: '',
    IngestPort: '',
    MaxBitrate: '',
    MaxLatency: '',
    MaxSyncBuffer: '',
    MediaStreamSourceConfigurations: '',
    MinLatency: '',
    Name: '',
    Protocol: '',
    SenderControlPort: '',
    SenderIpAddress: '',
    SourceListenerAddress: '',
    SourceListenerPort: '',
    StreamId: '',
    VpcInterfaceName: '',
    WhitelistCidr: '',
    GatewayBridgeSource: ''
  },
  sourceFailoverConfig: {
    FailoverMode: '',
    RecoveryWindow: '',
    SourcePriority: '',
    State: ''
  },
  sources: [
    {
      Decryption: '',
      Description: '',
      EntitlementArn: '',
      IngestPort: '',
      MaxBitrate: '',
      MaxLatency: '',
      MaxSyncBuffer: '',
      MediaStreamSourceConfigurations: '',
      MinLatency: '',
      Name: '',
      Protocol: '',
      SenderControlPort: '',
      SenderIpAddress: '',
      SourceListenerAddress: '',
      SourceListenerPort: '',
      StreamId: '',
      VpcInterfaceName: '',
      WhitelistCidr: '',
      GatewayBridgeSource: ''
    }
  ],
  vpcInterfaces: [
    {
      Name: '',
      NetworkInterfaceType: '',
      RoleArn: '',
      SecurityGroupIds: '',
      SubnetId: ''
    }
  ],
  maintenance: {
    MaintenanceDay: '',
    MaintenanceStartHour: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows',
  headers: {'content-type': 'application/json'},
  data: {
    availabilityZone: '',
    entitlements: [
      {
        DataTransferSubscriberFeePercent: '',
        Description: '',
        Encryption: '',
        EntitlementStatus: '',
        Name: '',
        Subscribers: ''
      }
    ],
    mediaStreams: [
      {
        Attributes: '',
        ClockRate: '',
        Description: '',
        MediaStreamId: '',
        MediaStreamName: '',
        MediaStreamType: '',
        VideoFormat: ''
      }
    ],
    name: '',
    outputs: [
      {
        CidrAllowList: '',
        Description: '',
        Destination: '',
        Encryption: '',
        MaxLatency: '',
        MediaStreamOutputConfigurations: '',
        MinLatency: '',
        Name: '',
        Port: '',
        Protocol: '',
        RemoteId: '',
        SenderControlPort: '',
        SmoothingLatency: '',
        StreamId: '',
        VpcInterfaceAttachment: ''
      }
    ],
    source: {
      Decryption: '',
      Description: '',
      EntitlementArn: '',
      IngestPort: '',
      MaxBitrate: '',
      MaxLatency: '',
      MaxSyncBuffer: '',
      MediaStreamSourceConfigurations: '',
      MinLatency: '',
      Name: '',
      Protocol: '',
      SenderControlPort: '',
      SenderIpAddress: '',
      SourceListenerAddress: '',
      SourceListenerPort: '',
      StreamId: '',
      VpcInterfaceName: '',
      WhitelistCidr: '',
      GatewayBridgeSource: ''
    },
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
    sources: [
      {
        Decryption: '',
        Description: '',
        EntitlementArn: '',
        IngestPort: '',
        MaxBitrate: '',
        MaxLatency: '',
        MaxSyncBuffer: '',
        MediaStreamSourceConfigurations: '',
        MinLatency: '',
        Name: '',
        Protocol: '',
        SenderControlPort: '',
        SenderIpAddress: '',
        SourceListenerAddress: '',
        SourceListenerPort: '',
        StreamId: '',
        VpcInterfaceName: '',
        WhitelistCidr: '',
        GatewayBridgeSource: ''
      }
    ],
    vpcInterfaces: [
      {
        Name: '',
        NetworkInterfaceType: '',
        RoleArn: '',
        SecurityGroupIds: '',
        SubnetId: ''
      }
    ],
    maintenance: {MaintenanceDay: '', MaintenanceStartHour: ''}
  }
};

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

const url = '{{baseUrl}}/v1/flows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"availabilityZone":"","entitlements":[{"DataTransferSubscriberFeePercent":"","Description":"","Encryption":"","EntitlementStatus":"","Name":"","Subscribers":""}],"mediaStreams":[{"Attributes":"","ClockRate":"","Description":"","MediaStreamId":"","MediaStreamName":"","MediaStreamType":"","VideoFormat":""}],"name":"","outputs":[{"CidrAllowList":"","Description":"","Destination":"","Encryption":"","MaxLatency":"","MediaStreamOutputConfigurations":"","MinLatency":"","Name":"","Port":"","Protocol":"","RemoteId":"","SenderControlPort":"","SmoothingLatency":"","StreamId":"","VpcInterfaceAttachment":""}],"source":{"Decryption":"","Description":"","EntitlementArn":"","IngestPort":"","MaxBitrate":"","MaxLatency":"","MaxSyncBuffer":"","MediaStreamSourceConfigurations":"","MinLatency":"","Name":"","Protocol":"","SenderControlPort":"","SenderIpAddress":"","SourceListenerAddress":"","SourceListenerPort":"","StreamId":"","VpcInterfaceName":"","WhitelistCidr":"","GatewayBridgeSource":""},"sourceFailoverConfig":{"FailoverMode":"","RecoveryWindow":"","SourcePriority":"","State":""},"sources":[{"Decryption":"","Description":"","EntitlementArn":"","IngestPort":"","MaxBitrate":"","MaxLatency":"","MaxSyncBuffer":"","MediaStreamSourceConfigurations":"","MinLatency":"","Name":"","Protocol":"","SenderControlPort":"","SenderIpAddress":"","SourceListenerAddress":"","SourceListenerPort":"","StreamId":"","VpcInterfaceName":"","WhitelistCidr":"","GatewayBridgeSource":""}],"vpcInterfaces":[{"Name":"","NetworkInterfaceType":"","RoleArn":"","SecurityGroupIds":"","SubnetId":""}],"maintenance":{"MaintenanceDay":"","MaintenanceStartHour":""}}'
};

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}}/v1/flows',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "availabilityZone": "",\n  "entitlements": [\n    {\n      "DataTransferSubscriberFeePercent": "",\n      "Description": "",\n      "Encryption": "",\n      "EntitlementStatus": "",\n      "Name": "",\n      "Subscribers": ""\n    }\n  ],\n  "mediaStreams": [\n    {\n      "Attributes": "",\n      "ClockRate": "",\n      "Description": "",\n      "MediaStreamId": "",\n      "MediaStreamName": "",\n      "MediaStreamType": "",\n      "VideoFormat": ""\n    }\n  ],\n  "name": "",\n  "outputs": [\n    {\n      "CidrAllowList": "",\n      "Description": "",\n      "Destination": "",\n      "Encryption": "",\n      "MaxLatency": "",\n      "MediaStreamOutputConfigurations": "",\n      "MinLatency": "",\n      "Name": "",\n      "Port": "",\n      "Protocol": "",\n      "RemoteId": "",\n      "SenderControlPort": "",\n      "SmoothingLatency": "",\n      "StreamId": "",\n      "VpcInterfaceAttachment": ""\n    }\n  ],\n  "source": {\n    "Decryption": "",\n    "Description": "",\n    "EntitlementArn": "",\n    "IngestPort": "",\n    "MaxBitrate": "",\n    "MaxLatency": "",\n    "MaxSyncBuffer": "",\n    "MediaStreamSourceConfigurations": "",\n    "MinLatency": "",\n    "Name": "",\n    "Protocol": "",\n    "SenderControlPort": "",\n    "SenderIpAddress": "",\n    "SourceListenerAddress": "",\n    "SourceListenerPort": "",\n    "StreamId": "",\n    "VpcInterfaceName": "",\n    "WhitelistCidr": "",\n    "GatewayBridgeSource": ""\n  },\n  "sourceFailoverConfig": {\n    "FailoverMode": "",\n    "RecoveryWindow": "",\n    "SourcePriority": "",\n    "State": ""\n  },\n  "sources": [\n    {\n      "Decryption": "",\n      "Description": "",\n      "EntitlementArn": "",\n      "IngestPort": "",\n      "MaxBitrate": "",\n      "MaxLatency": "",\n      "MaxSyncBuffer": "",\n      "MediaStreamSourceConfigurations": "",\n      "MinLatency": "",\n      "Name": "",\n      "Protocol": "",\n      "SenderControlPort": "",\n      "SenderIpAddress": "",\n      "SourceListenerAddress": "",\n      "SourceListenerPort": "",\n      "StreamId": "",\n      "VpcInterfaceName": "",\n      "WhitelistCidr": "",\n      "GatewayBridgeSource": ""\n    }\n  ],\n  "vpcInterfaces": [\n    {\n      "Name": "",\n      "NetworkInterfaceType": "",\n      "RoleArn": "",\n      "SecurityGroupIds": "",\n      "SubnetId": ""\n    }\n  ],\n  "maintenance": {\n    "MaintenanceDay": "",\n    "MaintenanceStartHour": ""\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  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows")
  .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/v1/flows',
  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({
  availabilityZone: '',
  entitlements: [
    {
      DataTransferSubscriberFeePercent: '',
      Description: '',
      Encryption: '',
      EntitlementStatus: '',
      Name: '',
      Subscribers: ''
    }
  ],
  mediaStreams: [
    {
      Attributes: '',
      ClockRate: '',
      Description: '',
      MediaStreamId: '',
      MediaStreamName: '',
      MediaStreamType: '',
      VideoFormat: ''
    }
  ],
  name: '',
  outputs: [
    {
      CidrAllowList: '',
      Description: '',
      Destination: '',
      Encryption: '',
      MaxLatency: '',
      MediaStreamOutputConfigurations: '',
      MinLatency: '',
      Name: '',
      Port: '',
      Protocol: '',
      RemoteId: '',
      SenderControlPort: '',
      SmoothingLatency: '',
      StreamId: '',
      VpcInterfaceAttachment: ''
    }
  ],
  source: {
    Decryption: '',
    Description: '',
    EntitlementArn: '',
    IngestPort: '',
    MaxBitrate: '',
    MaxLatency: '',
    MaxSyncBuffer: '',
    MediaStreamSourceConfigurations: '',
    MinLatency: '',
    Name: '',
    Protocol: '',
    SenderControlPort: '',
    SenderIpAddress: '',
    SourceListenerAddress: '',
    SourceListenerPort: '',
    StreamId: '',
    VpcInterfaceName: '',
    WhitelistCidr: '',
    GatewayBridgeSource: ''
  },
  sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
  sources: [
    {
      Decryption: '',
      Description: '',
      EntitlementArn: '',
      IngestPort: '',
      MaxBitrate: '',
      MaxLatency: '',
      MaxSyncBuffer: '',
      MediaStreamSourceConfigurations: '',
      MinLatency: '',
      Name: '',
      Protocol: '',
      SenderControlPort: '',
      SenderIpAddress: '',
      SourceListenerAddress: '',
      SourceListenerPort: '',
      StreamId: '',
      VpcInterfaceName: '',
      WhitelistCidr: '',
      GatewayBridgeSource: ''
    }
  ],
  vpcInterfaces: [
    {
      Name: '',
      NetworkInterfaceType: '',
      RoleArn: '',
      SecurityGroupIds: '',
      SubnetId: ''
    }
  ],
  maintenance: {MaintenanceDay: '', MaintenanceStartHour: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows',
  headers: {'content-type': 'application/json'},
  body: {
    availabilityZone: '',
    entitlements: [
      {
        DataTransferSubscriberFeePercent: '',
        Description: '',
        Encryption: '',
        EntitlementStatus: '',
        Name: '',
        Subscribers: ''
      }
    ],
    mediaStreams: [
      {
        Attributes: '',
        ClockRate: '',
        Description: '',
        MediaStreamId: '',
        MediaStreamName: '',
        MediaStreamType: '',
        VideoFormat: ''
      }
    ],
    name: '',
    outputs: [
      {
        CidrAllowList: '',
        Description: '',
        Destination: '',
        Encryption: '',
        MaxLatency: '',
        MediaStreamOutputConfigurations: '',
        MinLatency: '',
        Name: '',
        Port: '',
        Protocol: '',
        RemoteId: '',
        SenderControlPort: '',
        SmoothingLatency: '',
        StreamId: '',
        VpcInterfaceAttachment: ''
      }
    ],
    source: {
      Decryption: '',
      Description: '',
      EntitlementArn: '',
      IngestPort: '',
      MaxBitrate: '',
      MaxLatency: '',
      MaxSyncBuffer: '',
      MediaStreamSourceConfigurations: '',
      MinLatency: '',
      Name: '',
      Protocol: '',
      SenderControlPort: '',
      SenderIpAddress: '',
      SourceListenerAddress: '',
      SourceListenerPort: '',
      StreamId: '',
      VpcInterfaceName: '',
      WhitelistCidr: '',
      GatewayBridgeSource: ''
    },
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
    sources: [
      {
        Decryption: '',
        Description: '',
        EntitlementArn: '',
        IngestPort: '',
        MaxBitrate: '',
        MaxLatency: '',
        MaxSyncBuffer: '',
        MediaStreamSourceConfigurations: '',
        MinLatency: '',
        Name: '',
        Protocol: '',
        SenderControlPort: '',
        SenderIpAddress: '',
        SourceListenerAddress: '',
        SourceListenerPort: '',
        StreamId: '',
        VpcInterfaceName: '',
        WhitelistCidr: '',
        GatewayBridgeSource: ''
      }
    ],
    vpcInterfaces: [
      {
        Name: '',
        NetworkInterfaceType: '',
        RoleArn: '',
        SecurityGroupIds: '',
        SubnetId: ''
      }
    ],
    maintenance: {MaintenanceDay: '', MaintenanceStartHour: ''}
  },
  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}}/v1/flows');

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

req.type('json');
req.send({
  availabilityZone: '',
  entitlements: [
    {
      DataTransferSubscriberFeePercent: '',
      Description: '',
      Encryption: '',
      EntitlementStatus: '',
      Name: '',
      Subscribers: ''
    }
  ],
  mediaStreams: [
    {
      Attributes: '',
      ClockRate: '',
      Description: '',
      MediaStreamId: '',
      MediaStreamName: '',
      MediaStreamType: '',
      VideoFormat: ''
    }
  ],
  name: '',
  outputs: [
    {
      CidrAllowList: '',
      Description: '',
      Destination: '',
      Encryption: '',
      MaxLatency: '',
      MediaStreamOutputConfigurations: '',
      MinLatency: '',
      Name: '',
      Port: '',
      Protocol: '',
      RemoteId: '',
      SenderControlPort: '',
      SmoothingLatency: '',
      StreamId: '',
      VpcInterfaceAttachment: ''
    }
  ],
  source: {
    Decryption: '',
    Description: '',
    EntitlementArn: '',
    IngestPort: '',
    MaxBitrate: '',
    MaxLatency: '',
    MaxSyncBuffer: '',
    MediaStreamSourceConfigurations: '',
    MinLatency: '',
    Name: '',
    Protocol: '',
    SenderControlPort: '',
    SenderIpAddress: '',
    SourceListenerAddress: '',
    SourceListenerPort: '',
    StreamId: '',
    VpcInterfaceName: '',
    WhitelistCidr: '',
    GatewayBridgeSource: ''
  },
  sourceFailoverConfig: {
    FailoverMode: '',
    RecoveryWindow: '',
    SourcePriority: '',
    State: ''
  },
  sources: [
    {
      Decryption: '',
      Description: '',
      EntitlementArn: '',
      IngestPort: '',
      MaxBitrate: '',
      MaxLatency: '',
      MaxSyncBuffer: '',
      MediaStreamSourceConfigurations: '',
      MinLatency: '',
      Name: '',
      Protocol: '',
      SenderControlPort: '',
      SenderIpAddress: '',
      SourceListenerAddress: '',
      SourceListenerPort: '',
      StreamId: '',
      VpcInterfaceName: '',
      WhitelistCidr: '',
      GatewayBridgeSource: ''
    }
  ],
  vpcInterfaces: [
    {
      Name: '',
      NetworkInterfaceType: '',
      RoleArn: '',
      SecurityGroupIds: '',
      SubnetId: ''
    }
  ],
  maintenance: {
    MaintenanceDay: '',
    MaintenanceStartHour: ''
  }
});

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}}/v1/flows',
  headers: {'content-type': 'application/json'},
  data: {
    availabilityZone: '',
    entitlements: [
      {
        DataTransferSubscriberFeePercent: '',
        Description: '',
        Encryption: '',
        EntitlementStatus: '',
        Name: '',
        Subscribers: ''
      }
    ],
    mediaStreams: [
      {
        Attributes: '',
        ClockRate: '',
        Description: '',
        MediaStreamId: '',
        MediaStreamName: '',
        MediaStreamType: '',
        VideoFormat: ''
      }
    ],
    name: '',
    outputs: [
      {
        CidrAllowList: '',
        Description: '',
        Destination: '',
        Encryption: '',
        MaxLatency: '',
        MediaStreamOutputConfigurations: '',
        MinLatency: '',
        Name: '',
        Port: '',
        Protocol: '',
        RemoteId: '',
        SenderControlPort: '',
        SmoothingLatency: '',
        StreamId: '',
        VpcInterfaceAttachment: ''
      }
    ],
    source: {
      Decryption: '',
      Description: '',
      EntitlementArn: '',
      IngestPort: '',
      MaxBitrate: '',
      MaxLatency: '',
      MaxSyncBuffer: '',
      MediaStreamSourceConfigurations: '',
      MinLatency: '',
      Name: '',
      Protocol: '',
      SenderControlPort: '',
      SenderIpAddress: '',
      SourceListenerAddress: '',
      SourceListenerPort: '',
      StreamId: '',
      VpcInterfaceName: '',
      WhitelistCidr: '',
      GatewayBridgeSource: ''
    },
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
    sources: [
      {
        Decryption: '',
        Description: '',
        EntitlementArn: '',
        IngestPort: '',
        MaxBitrate: '',
        MaxLatency: '',
        MaxSyncBuffer: '',
        MediaStreamSourceConfigurations: '',
        MinLatency: '',
        Name: '',
        Protocol: '',
        SenderControlPort: '',
        SenderIpAddress: '',
        SourceListenerAddress: '',
        SourceListenerPort: '',
        StreamId: '',
        VpcInterfaceName: '',
        WhitelistCidr: '',
        GatewayBridgeSource: ''
      }
    ],
    vpcInterfaces: [
      {
        Name: '',
        NetworkInterfaceType: '',
        RoleArn: '',
        SecurityGroupIds: '',
        SubnetId: ''
      }
    ],
    maintenance: {MaintenanceDay: '', MaintenanceStartHour: ''}
  }
};

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

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

const url = '{{baseUrl}}/v1/flows';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"availabilityZone":"","entitlements":[{"DataTransferSubscriberFeePercent":"","Description":"","Encryption":"","EntitlementStatus":"","Name":"","Subscribers":""}],"mediaStreams":[{"Attributes":"","ClockRate":"","Description":"","MediaStreamId":"","MediaStreamName":"","MediaStreamType":"","VideoFormat":""}],"name":"","outputs":[{"CidrAllowList":"","Description":"","Destination":"","Encryption":"","MaxLatency":"","MediaStreamOutputConfigurations":"","MinLatency":"","Name":"","Port":"","Protocol":"","RemoteId":"","SenderControlPort":"","SmoothingLatency":"","StreamId":"","VpcInterfaceAttachment":""}],"source":{"Decryption":"","Description":"","EntitlementArn":"","IngestPort":"","MaxBitrate":"","MaxLatency":"","MaxSyncBuffer":"","MediaStreamSourceConfigurations":"","MinLatency":"","Name":"","Protocol":"","SenderControlPort":"","SenderIpAddress":"","SourceListenerAddress":"","SourceListenerPort":"","StreamId":"","VpcInterfaceName":"","WhitelistCidr":"","GatewayBridgeSource":""},"sourceFailoverConfig":{"FailoverMode":"","RecoveryWindow":"","SourcePriority":"","State":""},"sources":[{"Decryption":"","Description":"","EntitlementArn":"","IngestPort":"","MaxBitrate":"","MaxLatency":"","MaxSyncBuffer":"","MediaStreamSourceConfigurations":"","MinLatency":"","Name":"","Protocol":"","SenderControlPort":"","SenderIpAddress":"","SourceListenerAddress":"","SourceListenerPort":"","StreamId":"","VpcInterfaceName":"","WhitelistCidr":"","GatewayBridgeSource":""}],"vpcInterfaces":[{"Name":"","NetworkInterfaceType":"","RoleArn":"","SecurityGroupIds":"","SubnetId":""}],"maintenance":{"MaintenanceDay":"","MaintenanceStartHour":""}}'
};

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 = @{ @"availabilityZone": @"",
                              @"entitlements": @[ @{ @"DataTransferSubscriberFeePercent": @"", @"Description": @"", @"Encryption": @"", @"EntitlementStatus": @"", @"Name": @"", @"Subscribers": @"" } ],
                              @"mediaStreams": @[ @{ @"Attributes": @"", @"ClockRate": @"", @"Description": @"", @"MediaStreamId": @"", @"MediaStreamName": @"", @"MediaStreamType": @"", @"VideoFormat": @"" } ],
                              @"name": @"",
                              @"outputs": @[ @{ @"CidrAllowList": @"", @"Description": @"", @"Destination": @"", @"Encryption": @"", @"MaxLatency": @"", @"MediaStreamOutputConfigurations": @"", @"MinLatency": @"", @"Name": @"", @"Port": @"", @"Protocol": @"", @"RemoteId": @"", @"SenderControlPort": @"", @"SmoothingLatency": @"", @"StreamId": @"", @"VpcInterfaceAttachment": @"" } ],
                              @"source": @{ @"Decryption": @"", @"Description": @"", @"EntitlementArn": @"", @"IngestPort": @"", @"MaxBitrate": @"", @"MaxLatency": @"", @"MaxSyncBuffer": @"", @"MediaStreamSourceConfigurations": @"", @"MinLatency": @"", @"Name": @"", @"Protocol": @"", @"SenderControlPort": @"", @"SenderIpAddress": @"", @"SourceListenerAddress": @"", @"SourceListenerPort": @"", @"StreamId": @"", @"VpcInterfaceName": @"", @"WhitelistCidr": @"", @"GatewayBridgeSource": @"" },
                              @"sourceFailoverConfig": @{ @"FailoverMode": @"", @"RecoveryWindow": @"", @"SourcePriority": @"", @"State": @"" },
                              @"sources": @[ @{ @"Decryption": @"", @"Description": @"", @"EntitlementArn": @"", @"IngestPort": @"", @"MaxBitrate": @"", @"MaxLatency": @"", @"MaxSyncBuffer": @"", @"MediaStreamSourceConfigurations": @"", @"MinLatency": @"", @"Name": @"", @"Protocol": @"", @"SenderControlPort": @"", @"SenderIpAddress": @"", @"SourceListenerAddress": @"", @"SourceListenerPort": @"", @"StreamId": @"", @"VpcInterfaceName": @"", @"WhitelistCidr": @"", @"GatewayBridgeSource": @"" } ],
                              @"vpcInterfaces": @[ @{ @"Name": @"", @"NetworkInterfaceType": @"", @"RoleArn": @"", @"SecurityGroupIds": @"", @"SubnetId": @"" } ],
                              @"maintenance": @{ @"MaintenanceDay": @"", @"MaintenanceStartHour": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows"]
                                                       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}}/v1/flows" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1/flows",
  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([
    'availabilityZone' => '',
    'entitlements' => [
        [
                'DataTransferSubscriberFeePercent' => '',
                'Description' => '',
                'Encryption' => '',
                'EntitlementStatus' => '',
                'Name' => '',
                'Subscribers' => ''
        ]
    ],
    'mediaStreams' => [
        [
                'Attributes' => '',
                'ClockRate' => '',
                'Description' => '',
                'MediaStreamId' => '',
                'MediaStreamName' => '',
                'MediaStreamType' => '',
                'VideoFormat' => ''
        ]
    ],
    'name' => '',
    'outputs' => [
        [
                'CidrAllowList' => '',
                'Description' => '',
                'Destination' => '',
                'Encryption' => '',
                'MaxLatency' => '',
                'MediaStreamOutputConfigurations' => '',
                'MinLatency' => '',
                'Name' => '',
                'Port' => '',
                'Protocol' => '',
                'RemoteId' => '',
                'SenderControlPort' => '',
                'SmoothingLatency' => '',
                'StreamId' => '',
                'VpcInterfaceAttachment' => ''
        ]
    ],
    'source' => [
        'Decryption' => '',
        'Description' => '',
        'EntitlementArn' => '',
        'IngestPort' => '',
        'MaxBitrate' => '',
        'MaxLatency' => '',
        'MaxSyncBuffer' => '',
        'MediaStreamSourceConfigurations' => '',
        'MinLatency' => '',
        'Name' => '',
        'Protocol' => '',
        'SenderControlPort' => '',
        'SenderIpAddress' => '',
        'SourceListenerAddress' => '',
        'SourceListenerPort' => '',
        'StreamId' => '',
        'VpcInterfaceName' => '',
        'WhitelistCidr' => '',
        'GatewayBridgeSource' => ''
    ],
    'sourceFailoverConfig' => [
        'FailoverMode' => '',
        'RecoveryWindow' => '',
        'SourcePriority' => '',
        'State' => ''
    ],
    'sources' => [
        [
                'Decryption' => '',
                'Description' => '',
                'EntitlementArn' => '',
                'IngestPort' => '',
                'MaxBitrate' => '',
                'MaxLatency' => '',
                'MaxSyncBuffer' => '',
                'MediaStreamSourceConfigurations' => '',
                'MinLatency' => '',
                'Name' => '',
                'Protocol' => '',
                'SenderControlPort' => '',
                'SenderIpAddress' => '',
                'SourceListenerAddress' => '',
                'SourceListenerPort' => '',
                'StreamId' => '',
                'VpcInterfaceName' => '',
                'WhitelistCidr' => '',
                'GatewayBridgeSource' => ''
        ]
    ],
    'vpcInterfaces' => [
        [
                'Name' => '',
                'NetworkInterfaceType' => '',
                'RoleArn' => '',
                'SecurityGroupIds' => '',
                'SubnetId' => ''
        ]
    ],
    'maintenance' => [
        'MaintenanceDay' => '',
        'MaintenanceStartHour' => ''
    ]
  ]),
  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}}/v1/flows', [
  'body' => '{
  "availabilityZone": "",
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ],
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ],
  "name": "",
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ],
  "source": {
    "Decryption": "",
    "Description": "",
    "EntitlementArn": "",
    "IngestPort": "",
    "MaxBitrate": "",
    "MaxLatency": "",
    "MaxSyncBuffer": "",
    "MediaStreamSourceConfigurations": "",
    "MinLatency": "",
    "Name": "",
    "Protocol": "",
    "SenderControlPort": "",
    "SenderIpAddress": "",
    "SourceListenerAddress": "",
    "SourceListenerPort": "",
    "StreamId": "",
    "VpcInterfaceName": "",
    "WhitelistCidr": "",
    "GatewayBridgeSource": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ],
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ],
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartHour": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'availabilityZone' => '',
  'entitlements' => [
    [
        'DataTransferSubscriberFeePercent' => '',
        'Description' => '',
        'Encryption' => '',
        'EntitlementStatus' => '',
        'Name' => '',
        'Subscribers' => ''
    ]
  ],
  'mediaStreams' => [
    [
        'Attributes' => '',
        'ClockRate' => '',
        'Description' => '',
        'MediaStreamId' => '',
        'MediaStreamName' => '',
        'MediaStreamType' => '',
        'VideoFormat' => ''
    ]
  ],
  'name' => '',
  'outputs' => [
    [
        'CidrAllowList' => '',
        'Description' => '',
        'Destination' => '',
        'Encryption' => '',
        'MaxLatency' => '',
        'MediaStreamOutputConfigurations' => '',
        'MinLatency' => '',
        'Name' => '',
        'Port' => '',
        'Protocol' => '',
        'RemoteId' => '',
        'SenderControlPort' => '',
        'SmoothingLatency' => '',
        'StreamId' => '',
        'VpcInterfaceAttachment' => ''
    ]
  ],
  'source' => [
    'Decryption' => '',
    'Description' => '',
    'EntitlementArn' => '',
    'IngestPort' => '',
    'MaxBitrate' => '',
    'MaxLatency' => '',
    'MaxSyncBuffer' => '',
    'MediaStreamSourceConfigurations' => '',
    'MinLatency' => '',
    'Name' => '',
    'Protocol' => '',
    'SenderControlPort' => '',
    'SenderIpAddress' => '',
    'SourceListenerAddress' => '',
    'SourceListenerPort' => '',
    'StreamId' => '',
    'VpcInterfaceName' => '',
    'WhitelistCidr' => '',
    'GatewayBridgeSource' => ''
  ],
  'sourceFailoverConfig' => [
    'FailoverMode' => '',
    'RecoveryWindow' => '',
    'SourcePriority' => '',
    'State' => ''
  ],
  'sources' => [
    [
        'Decryption' => '',
        'Description' => '',
        'EntitlementArn' => '',
        'IngestPort' => '',
        'MaxBitrate' => '',
        'MaxLatency' => '',
        'MaxSyncBuffer' => '',
        'MediaStreamSourceConfigurations' => '',
        'MinLatency' => '',
        'Name' => '',
        'Protocol' => '',
        'SenderControlPort' => '',
        'SenderIpAddress' => '',
        'SourceListenerAddress' => '',
        'SourceListenerPort' => '',
        'StreamId' => '',
        'VpcInterfaceName' => '',
        'WhitelistCidr' => '',
        'GatewayBridgeSource' => ''
    ]
  ],
  'vpcInterfaces' => [
    [
        'Name' => '',
        'NetworkInterfaceType' => '',
        'RoleArn' => '',
        'SecurityGroupIds' => '',
        'SubnetId' => ''
    ]
  ],
  'maintenance' => [
    'MaintenanceDay' => '',
    'MaintenanceStartHour' => ''
  ]
]));

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

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

append(json_encode([
  'availabilityZone' => '',
  'entitlements' => [
    [
        'DataTransferSubscriberFeePercent' => '',
        'Description' => '',
        'Encryption' => '',
        'EntitlementStatus' => '',
        'Name' => '',
        'Subscribers' => ''
    ]
  ],
  'mediaStreams' => [
    [
        'Attributes' => '',
        'ClockRate' => '',
        'Description' => '',
        'MediaStreamId' => '',
        'MediaStreamName' => '',
        'MediaStreamType' => '',
        'VideoFormat' => ''
    ]
  ],
  'name' => '',
  'outputs' => [
    [
        'CidrAllowList' => '',
        'Description' => '',
        'Destination' => '',
        'Encryption' => '',
        'MaxLatency' => '',
        'MediaStreamOutputConfigurations' => '',
        'MinLatency' => '',
        'Name' => '',
        'Port' => '',
        'Protocol' => '',
        'RemoteId' => '',
        'SenderControlPort' => '',
        'SmoothingLatency' => '',
        'StreamId' => '',
        'VpcInterfaceAttachment' => ''
    ]
  ],
  'source' => [
    'Decryption' => '',
    'Description' => '',
    'EntitlementArn' => '',
    'IngestPort' => '',
    'MaxBitrate' => '',
    'MaxLatency' => '',
    'MaxSyncBuffer' => '',
    'MediaStreamSourceConfigurations' => '',
    'MinLatency' => '',
    'Name' => '',
    'Protocol' => '',
    'SenderControlPort' => '',
    'SenderIpAddress' => '',
    'SourceListenerAddress' => '',
    'SourceListenerPort' => '',
    'StreamId' => '',
    'VpcInterfaceName' => '',
    'WhitelistCidr' => '',
    'GatewayBridgeSource' => ''
  ],
  'sourceFailoverConfig' => [
    'FailoverMode' => '',
    'RecoveryWindow' => '',
    'SourcePriority' => '',
    'State' => ''
  ],
  'sources' => [
    [
        'Decryption' => '',
        'Description' => '',
        'EntitlementArn' => '',
        'IngestPort' => '',
        'MaxBitrate' => '',
        'MaxLatency' => '',
        'MaxSyncBuffer' => '',
        'MediaStreamSourceConfigurations' => '',
        'MinLatency' => '',
        'Name' => '',
        'Protocol' => '',
        'SenderControlPort' => '',
        'SenderIpAddress' => '',
        'SourceListenerAddress' => '',
        'SourceListenerPort' => '',
        'StreamId' => '',
        'VpcInterfaceName' => '',
        'WhitelistCidr' => '',
        'GatewayBridgeSource' => ''
    ]
  ],
  'vpcInterfaces' => [
    [
        'Name' => '',
        'NetworkInterfaceType' => '',
        'RoleArn' => '',
        'SecurityGroupIds' => '',
        'SubnetId' => ''
    ]
  ],
  'maintenance' => [
    'MaintenanceDay' => '',
    'MaintenanceStartHour' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/flows');
$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}}/v1/flows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "availabilityZone": "",
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ],
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ],
  "name": "",
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ],
  "source": {
    "Decryption": "",
    "Description": "",
    "EntitlementArn": "",
    "IngestPort": "",
    "MaxBitrate": "",
    "MaxLatency": "",
    "MaxSyncBuffer": "",
    "MediaStreamSourceConfigurations": "",
    "MinLatency": "",
    "Name": "",
    "Protocol": "",
    "SenderControlPort": "",
    "SenderIpAddress": "",
    "SourceListenerAddress": "",
    "SourceListenerPort": "",
    "StreamId": "",
    "VpcInterfaceName": "",
    "WhitelistCidr": "",
    "GatewayBridgeSource": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ],
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ],
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartHour": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "availabilityZone": "",
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ],
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ],
  "name": "",
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ],
  "source": {
    "Decryption": "",
    "Description": "",
    "EntitlementArn": "",
    "IngestPort": "",
    "MaxBitrate": "",
    "MaxLatency": "",
    "MaxSyncBuffer": "",
    "MediaStreamSourceConfigurations": "",
    "MinLatency": "",
    "Name": "",
    "Protocol": "",
    "SenderControlPort": "",
    "SenderIpAddress": "",
    "SourceListenerAddress": "",
    "SourceListenerPort": "",
    "StreamId": "",
    "VpcInterfaceName": "",
    "WhitelistCidr": "",
    "GatewayBridgeSource": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ],
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ],
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartHour": ""
  }
}'

import http.client

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

payload = "{\n  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/v1/flows"

payload = {
    "availabilityZone": "",
    "entitlements": [
        {
            "DataTransferSubscriberFeePercent": "",
            "Description": "",
            "Encryption": "",
            "EntitlementStatus": "",
            "Name": "",
            "Subscribers": ""
        }
    ],
    "mediaStreams": [
        {
            "Attributes": "",
            "ClockRate": "",
            "Description": "",
            "MediaStreamId": "",
            "MediaStreamName": "",
            "MediaStreamType": "",
            "VideoFormat": ""
        }
    ],
    "name": "",
    "outputs": [
        {
            "CidrAllowList": "",
            "Description": "",
            "Destination": "",
            "Encryption": "",
            "MaxLatency": "",
            "MediaStreamOutputConfigurations": "",
            "MinLatency": "",
            "Name": "",
            "Port": "",
            "Protocol": "",
            "RemoteId": "",
            "SenderControlPort": "",
            "SmoothingLatency": "",
            "StreamId": "",
            "VpcInterfaceAttachment": ""
        }
    ],
    "source": {
        "Decryption": "",
        "Description": "",
        "EntitlementArn": "",
        "IngestPort": "",
        "MaxBitrate": "",
        "MaxLatency": "",
        "MaxSyncBuffer": "",
        "MediaStreamSourceConfigurations": "",
        "MinLatency": "",
        "Name": "",
        "Protocol": "",
        "SenderControlPort": "",
        "SenderIpAddress": "",
        "SourceListenerAddress": "",
        "SourceListenerPort": "",
        "StreamId": "",
        "VpcInterfaceName": "",
        "WhitelistCidr": "",
        "GatewayBridgeSource": ""
    },
    "sourceFailoverConfig": {
        "FailoverMode": "",
        "RecoveryWindow": "",
        "SourcePriority": "",
        "State": ""
    },
    "sources": [
        {
            "Decryption": "",
            "Description": "",
            "EntitlementArn": "",
            "IngestPort": "",
            "MaxBitrate": "",
            "MaxLatency": "",
            "MaxSyncBuffer": "",
            "MediaStreamSourceConfigurations": "",
            "MinLatency": "",
            "Name": "",
            "Protocol": "",
            "SenderControlPort": "",
            "SenderIpAddress": "",
            "SourceListenerAddress": "",
            "SourceListenerPort": "",
            "StreamId": "",
            "VpcInterfaceName": "",
            "WhitelistCidr": "",
            "GatewayBridgeSource": ""
        }
    ],
    "vpcInterfaces": [
        {
            "Name": "",
            "NetworkInterfaceType": "",
            "RoleArn": "",
            "SecurityGroupIds": "",
            "SubnetId": ""
        }
    ],
    "maintenance": {
        "MaintenanceDay": "",
        "MaintenanceStartHour": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows"

payload <- "{\n  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\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}}/v1/flows")

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  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\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/v1/flows') do |req|
  req.body = "{\n  \"availabilityZone\": \"\",\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ],\n  \"mediaStreams\": [\n    {\n      \"Attributes\": \"\",\n      \"ClockRate\": \"\",\n      \"Description\": \"\",\n      \"MediaStreamId\": \"\",\n      \"MediaStreamName\": \"\",\n      \"MediaStreamType\": \"\",\n      \"VideoFormat\": \"\"\n    }\n  ],\n  \"name\": \"\",\n  \"outputs\": [\n    {\n      \"CidrAllowList\": \"\",\n      \"Description\": \"\",\n      \"Destination\": \"\",\n      \"Encryption\": \"\",\n      \"MaxLatency\": \"\",\n      \"MediaStreamOutputConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Port\": \"\",\n      \"Protocol\": \"\",\n      \"RemoteId\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SmoothingLatency\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceAttachment\": \"\"\n    }\n  ],\n  \"source\": {\n    \"Decryption\": \"\",\n    \"Description\": \"\",\n    \"EntitlementArn\": \"\",\n    \"IngestPort\": \"\",\n    \"MaxBitrate\": \"\",\n    \"MaxLatency\": \"\",\n    \"MaxSyncBuffer\": \"\",\n    \"MediaStreamSourceConfigurations\": \"\",\n    \"MinLatency\": \"\",\n    \"Name\": \"\",\n    \"Protocol\": \"\",\n    \"SenderControlPort\": \"\",\n    \"SenderIpAddress\": \"\",\n    \"SourceListenerAddress\": \"\",\n    \"SourceListenerPort\": \"\",\n    \"StreamId\": \"\",\n    \"VpcInterfaceName\": \"\",\n    \"WhitelistCidr\": \"\",\n    \"GatewayBridgeSource\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"sources\": [\n    {\n      \"Decryption\": \"\",\n      \"Description\": \"\",\n      \"EntitlementArn\": \"\",\n      \"IngestPort\": \"\",\n      \"MaxBitrate\": \"\",\n      \"MaxLatency\": \"\",\n      \"MaxSyncBuffer\": \"\",\n      \"MediaStreamSourceConfigurations\": \"\",\n      \"MinLatency\": \"\",\n      \"Name\": \"\",\n      \"Protocol\": \"\",\n      \"SenderControlPort\": \"\",\n      \"SenderIpAddress\": \"\",\n      \"SourceListenerAddress\": \"\",\n      \"SourceListenerPort\": \"\",\n      \"StreamId\": \"\",\n      \"VpcInterfaceName\": \"\",\n      \"WhitelistCidr\": \"\",\n      \"GatewayBridgeSource\": \"\"\n    }\n  ],\n  \"vpcInterfaces\": [\n    {\n      \"Name\": \"\",\n      \"NetworkInterfaceType\": \"\",\n      \"RoleArn\": \"\",\n      \"SecurityGroupIds\": \"\",\n      \"SubnetId\": \"\"\n    }\n  ],\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "availabilityZone": "",
        "entitlements": (
            json!({
                "DataTransferSubscriberFeePercent": "",
                "Description": "",
                "Encryption": "",
                "EntitlementStatus": "",
                "Name": "",
                "Subscribers": ""
            })
        ),
        "mediaStreams": (
            json!({
                "Attributes": "",
                "ClockRate": "",
                "Description": "",
                "MediaStreamId": "",
                "MediaStreamName": "",
                "MediaStreamType": "",
                "VideoFormat": ""
            })
        ),
        "name": "",
        "outputs": (
            json!({
                "CidrAllowList": "",
                "Description": "",
                "Destination": "",
                "Encryption": "",
                "MaxLatency": "",
                "MediaStreamOutputConfigurations": "",
                "MinLatency": "",
                "Name": "",
                "Port": "",
                "Protocol": "",
                "RemoteId": "",
                "SenderControlPort": "",
                "SmoothingLatency": "",
                "StreamId": "",
                "VpcInterfaceAttachment": ""
            })
        ),
        "source": json!({
            "Decryption": "",
            "Description": "",
            "EntitlementArn": "",
            "IngestPort": "",
            "MaxBitrate": "",
            "MaxLatency": "",
            "MaxSyncBuffer": "",
            "MediaStreamSourceConfigurations": "",
            "MinLatency": "",
            "Name": "",
            "Protocol": "",
            "SenderControlPort": "",
            "SenderIpAddress": "",
            "SourceListenerAddress": "",
            "SourceListenerPort": "",
            "StreamId": "",
            "VpcInterfaceName": "",
            "WhitelistCidr": "",
            "GatewayBridgeSource": ""
        }),
        "sourceFailoverConfig": json!({
            "FailoverMode": "",
            "RecoveryWindow": "",
            "SourcePriority": "",
            "State": ""
        }),
        "sources": (
            json!({
                "Decryption": "",
                "Description": "",
                "EntitlementArn": "",
                "IngestPort": "",
                "MaxBitrate": "",
                "MaxLatency": "",
                "MaxSyncBuffer": "",
                "MediaStreamSourceConfigurations": "",
                "MinLatency": "",
                "Name": "",
                "Protocol": "",
                "SenderControlPort": "",
                "SenderIpAddress": "",
                "SourceListenerAddress": "",
                "SourceListenerPort": "",
                "StreamId": "",
                "VpcInterfaceName": "",
                "WhitelistCidr": "",
                "GatewayBridgeSource": ""
            })
        ),
        "vpcInterfaces": (
            json!({
                "Name": "",
                "NetworkInterfaceType": "",
                "RoleArn": "",
                "SecurityGroupIds": "",
                "SubnetId": ""
            })
        ),
        "maintenance": json!({
            "MaintenanceDay": "",
            "MaintenanceStartHour": ""
        })
    });

    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}}/v1/flows \
  --header 'content-type: application/json' \
  --data '{
  "availabilityZone": "",
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ],
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ],
  "name": "",
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ],
  "source": {
    "Decryption": "",
    "Description": "",
    "EntitlementArn": "",
    "IngestPort": "",
    "MaxBitrate": "",
    "MaxLatency": "",
    "MaxSyncBuffer": "",
    "MediaStreamSourceConfigurations": "",
    "MinLatency": "",
    "Name": "",
    "Protocol": "",
    "SenderControlPort": "",
    "SenderIpAddress": "",
    "SourceListenerAddress": "",
    "SourceListenerPort": "",
    "StreamId": "",
    "VpcInterfaceName": "",
    "WhitelistCidr": "",
    "GatewayBridgeSource": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ],
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ],
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartHour": ""
  }
}'

echo '{
  "availabilityZone": "",
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ],
  "mediaStreams": [
    {
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    }
  ],
  "name": "",
  "outputs": [
    {
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    }
  ],
  "source": {
    "Decryption": "",
    "Description": "",
    "EntitlementArn": "",
    "IngestPort": "",
    "MaxBitrate": "",
    "MaxLatency": "",
    "MaxSyncBuffer": "",
    "MediaStreamSourceConfigurations": "",
    "MinLatency": "",
    "Name": "",
    "Protocol": "",
    "SenderControlPort": "",
    "SenderIpAddress": "",
    "SourceListenerAddress": "",
    "SourceListenerPort": "",
    "StreamId": "",
    "VpcInterfaceName": "",
    "WhitelistCidr": "",
    "GatewayBridgeSource": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "sources": [
    {
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    }
  ],
  "vpcInterfaces": [
    {
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    }
  ],
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceStartHour": ""
  }
}' |  \
  http POST {{baseUrl}}/v1/flows \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "availabilityZone": "",\n  "entitlements": [\n    {\n      "DataTransferSubscriberFeePercent": "",\n      "Description": "",\n      "Encryption": "",\n      "EntitlementStatus": "",\n      "Name": "",\n      "Subscribers": ""\n    }\n  ],\n  "mediaStreams": [\n    {\n      "Attributes": "",\n      "ClockRate": "",\n      "Description": "",\n      "MediaStreamId": "",\n      "MediaStreamName": "",\n      "MediaStreamType": "",\n      "VideoFormat": ""\n    }\n  ],\n  "name": "",\n  "outputs": [\n    {\n      "CidrAllowList": "",\n      "Description": "",\n      "Destination": "",\n      "Encryption": "",\n      "MaxLatency": "",\n      "MediaStreamOutputConfigurations": "",\n      "MinLatency": "",\n      "Name": "",\n      "Port": "",\n      "Protocol": "",\n      "RemoteId": "",\n      "SenderControlPort": "",\n      "SmoothingLatency": "",\n      "StreamId": "",\n      "VpcInterfaceAttachment": ""\n    }\n  ],\n  "source": {\n    "Decryption": "",\n    "Description": "",\n    "EntitlementArn": "",\n    "IngestPort": "",\n    "MaxBitrate": "",\n    "MaxLatency": "",\n    "MaxSyncBuffer": "",\n    "MediaStreamSourceConfigurations": "",\n    "MinLatency": "",\n    "Name": "",\n    "Protocol": "",\n    "SenderControlPort": "",\n    "SenderIpAddress": "",\n    "SourceListenerAddress": "",\n    "SourceListenerPort": "",\n    "StreamId": "",\n    "VpcInterfaceName": "",\n    "WhitelistCidr": "",\n    "GatewayBridgeSource": ""\n  },\n  "sourceFailoverConfig": {\n    "FailoverMode": "",\n    "RecoveryWindow": "",\n    "SourcePriority": "",\n    "State": ""\n  },\n  "sources": [\n    {\n      "Decryption": "",\n      "Description": "",\n      "EntitlementArn": "",\n      "IngestPort": "",\n      "MaxBitrate": "",\n      "MaxLatency": "",\n      "MaxSyncBuffer": "",\n      "MediaStreamSourceConfigurations": "",\n      "MinLatency": "",\n      "Name": "",\n      "Protocol": "",\n      "SenderControlPort": "",\n      "SenderIpAddress": "",\n      "SourceListenerAddress": "",\n      "SourceListenerPort": "",\n      "StreamId": "",\n      "VpcInterfaceName": "",\n      "WhitelistCidr": "",\n      "GatewayBridgeSource": ""\n    }\n  ],\n  "vpcInterfaces": [\n    {\n      "Name": "",\n      "NetworkInterfaceType": "",\n      "RoleArn": "",\n      "SecurityGroupIds": "",\n      "SubnetId": ""\n    }\n  ],\n  "maintenance": {\n    "MaintenanceDay": "",\n    "MaintenanceStartHour": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/flows

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "availabilityZone": "",
  "entitlements": [
    [
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    ]
  ],
  "mediaStreams": [
    [
      "Attributes": "",
      "ClockRate": "",
      "Description": "",
      "MediaStreamId": "",
      "MediaStreamName": "",
      "MediaStreamType": "",
      "VideoFormat": ""
    ]
  ],
  "name": "",
  "outputs": [
    [
      "CidrAllowList": "",
      "Description": "",
      "Destination": "",
      "Encryption": "",
      "MaxLatency": "",
      "MediaStreamOutputConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Port": "",
      "Protocol": "",
      "RemoteId": "",
      "SenderControlPort": "",
      "SmoothingLatency": "",
      "StreamId": "",
      "VpcInterfaceAttachment": ""
    ]
  ],
  "source": [
    "Decryption": "",
    "Description": "",
    "EntitlementArn": "",
    "IngestPort": "",
    "MaxBitrate": "",
    "MaxLatency": "",
    "MaxSyncBuffer": "",
    "MediaStreamSourceConfigurations": "",
    "MinLatency": "",
    "Name": "",
    "Protocol": "",
    "SenderControlPort": "",
    "SenderIpAddress": "",
    "SourceListenerAddress": "",
    "SourceListenerPort": "",
    "StreamId": "",
    "VpcInterfaceName": "",
    "WhitelistCidr": "",
    "GatewayBridgeSource": ""
  ],
  "sourceFailoverConfig": [
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  ],
  "sources": [
    [
      "Decryption": "",
      "Description": "",
      "EntitlementArn": "",
      "IngestPort": "",
      "MaxBitrate": "",
      "MaxLatency": "",
      "MaxSyncBuffer": "",
      "MediaStreamSourceConfigurations": "",
      "MinLatency": "",
      "Name": "",
      "Protocol": "",
      "SenderControlPort": "",
      "SenderIpAddress": "",
      "SourceListenerAddress": "",
      "SourceListenerPort": "",
      "StreamId": "",
      "VpcInterfaceName": "",
      "WhitelistCidr": "",
      "GatewayBridgeSource": ""
    ]
  ],
  "vpcInterfaces": [
    [
      "Name": "",
      "NetworkInterfaceType": "",
      "RoleArn": "",
      "SecurityGroupIds": "",
      "SubnetId": ""
    ]
  ],
  "maintenance": [
    "MaintenanceDay": "",
    "MaintenanceStartHour": ""
  ]
] as [String : Any]

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

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

{{baseUrl}}/v1/gateways

BODY json

{
  "egressCidrBlocks": [],
  "name": "",
  "networks": [
    {
      "CidrBlock": "",
      "Name": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/gateways" {:content-type :json
                                                        :form-params {:egressCidrBlocks []
                                                                      :name ""
                                                                      :networks [{:CidrBlock ""
                                                                                  :Name ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/gateways"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/gateways"),
    Content = new StringContent("{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/gateways");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/gateways"

	payload := strings.NewReader("{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/gateways HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 115

{
  "egressCidrBlocks": [],
  "name": "",
  "networks": [
    {
      "CidrBlock": "",
      "Name": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/gateways")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/gateways"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/gateways")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/gateways")
  .header("content-type", "application/json")
  .body("{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  egressCidrBlocks: [],
  name: '',
  networks: [
    {
      CidrBlock: '',
      Name: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/gateways',
  headers: {'content-type': 'application/json'},
  data: {egressCidrBlocks: [], name: '', networks: [{CidrBlock: '', Name: ''}]}
};

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

const url = '{{baseUrl}}/v1/gateways';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"egressCidrBlocks":[],"name":"","networks":[{"CidrBlock":"","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}}/v1/gateways',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "egressCidrBlocks": [],\n  "name": "",\n  "networks": [\n    {\n      "CidrBlock": "",\n      "Name": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/gateways")
  .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/v1/gateways',
  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({egressCidrBlocks: [], name: '', networks: [{CidrBlock: '', Name: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/gateways',
  headers: {'content-type': 'application/json'},
  body: {egressCidrBlocks: [], name: '', networks: [{CidrBlock: '', 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('POST', '{{baseUrl}}/v1/gateways');

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

req.type('json');
req.send({
  egressCidrBlocks: [],
  name: '',
  networks: [
    {
      CidrBlock: '',
      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: 'POST',
  url: '{{baseUrl}}/v1/gateways',
  headers: {'content-type': 'application/json'},
  data: {egressCidrBlocks: [], name: '', networks: [{CidrBlock: '', Name: ''}]}
};

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

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

const url = '{{baseUrl}}/v1/gateways';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"egressCidrBlocks":[],"name":"","networks":[{"CidrBlock":"","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 = @{ @"egressCidrBlocks": @[  ],
                              @"name": @"",
                              @"networks": @[ @{ @"CidrBlock": @"", @"Name": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/gateways"]
                                                       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}}/v1/gateways" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1/gateways",
  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([
    'egressCidrBlocks' => [
        
    ],
    'name' => '',
    'networks' => [
        [
                'CidrBlock' => '',
                '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('POST', '{{baseUrl}}/v1/gateways', [
  'body' => '{
  "egressCidrBlocks": [],
  "name": "",
  "networks": [
    {
      "CidrBlock": "",
      "Name": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'egressCidrBlocks' => [
    
  ],
  'name' => '',
  'networks' => [
    [
        'CidrBlock' => '',
        'Name' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'egressCidrBlocks' => [
    
  ],
  'name' => '',
  'networks' => [
    [
        'CidrBlock' => '',
        'Name' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/gateways');
$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}}/v1/gateways' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "egressCidrBlocks": [],
  "name": "",
  "networks": [
    {
      "CidrBlock": "",
      "Name": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/gateways' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "egressCidrBlocks": [],
  "name": "",
  "networks": [
    {
      "CidrBlock": "",
      "Name": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/v1/gateways"

payload = {
    "egressCidrBlocks": [],
    "name": "",
    "networks": [
        {
            "CidrBlock": "",
            "Name": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/gateways"

payload <- "{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/gateways")

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  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/gateways') do |req|
  req.body = "{\n  \"egressCidrBlocks\": [],\n  \"name\": \"\",\n  \"networks\": [\n    {\n      \"CidrBlock\": \"\",\n      \"Name\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "egressCidrBlocks": (),
        "name": "",
        "networks": (
            json!({
                "CidrBlock": "",
                "Name": ""
            })
        )
    });

    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}}/v1/gateways \
  --header 'content-type: application/json' \
  --data '{
  "egressCidrBlocks": [],
  "name": "",
  "networks": [
    {
      "CidrBlock": "",
      "Name": ""
    }
  ]
}'

echo '{
  "egressCidrBlocks": [],
  "name": "",
  "networks": [
    {
      "CidrBlock": "",
      "Name": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/gateways \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "egressCidrBlocks": [],\n  "name": "",\n  "networks": [\n    {\n      "CidrBlock": "",\n      "Name": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/gateways

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "egressCidrBlocks": [],
  "name": "",
  "networks": [
    [
      "CidrBlock": "",
      "Name": ""
    ]
  ]
] as [String : Any]

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

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

{{baseUrl}}/v1/bridges/:bridgeArn

QUERY PARAMS

bridgeArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/bridges/:bridgeArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/bridges/:bridgeArn")

require "http/client"

url = "{{baseUrl}}/v1/bridges/:bridgeArn"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/bridges/:bridgeArn"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/bridges/:bridgeArn'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/bridges/:bridgeArn');

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}}/v1/bridges/:bridgeArn'};

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

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

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

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

 "{{baseUrl}}/v1/bridges/:bridgeArn",
  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}}/v1/bridges/:bridgeArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/bridges/:bridgeArn');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/bridges/:bridgeArn' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/bridges/:bridgeArn' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/bridges/:bridgeArn")

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

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

import requests

url = "{{baseUrl}}/v1/bridges/:bridgeArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges/:bridgeArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/bridges/:bridgeArn")

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/v1/bridges/:bridgeArn') do |req|
end

puts response.status
puts response.body

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

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

    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}}/v1/bridges/:bridgeArn

http DELETE {{baseUrl}}/v1/bridges/:bridgeArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/bridges/:bridgeArn

import Foundation

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

{{baseUrl}}/v1/flows/:flowArn

QUERY PARAMS

flowArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/flows/:flowArn")

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/flows/:flowArn'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/flows/:flowArn');

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}}/v1/flows/:flowArn'};

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

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

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

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

 "{{baseUrl}}/v1/flows/:flowArn",
  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}}/v1/flows/:flowArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/flows/:flowArn' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/flows/:flowArn")

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

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

import requests

url = "{{baseUrl}}/v1/flows/:flowArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn")

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/v1/flows/:flowArn') do |req|
end

puts response.status
puts response.body

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

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

    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}}/v1/flows/:flowArn

http DELETE {{baseUrl}}/v1/flows/:flowArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn

import Foundation

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

{{baseUrl}}/v1/gateways/:gatewayArn

QUERY PARAMS

gatewayArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/gateways/:gatewayArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/gateways/:gatewayArn")

require "http/client"

url = "{{baseUrl}}/v1/gateways/:gatewayArn"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/gateways/:gatewayArn"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1/gateways/:gatewayArn'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/gateways/:gatewayArn")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/gateways/:gatewayArn');

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}}/v1/gateways/:gatewayArn'};

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

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

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

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

 "{{baseUrl}}/v1/gateways/:gatewayArn",
  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}}/v1/gateways/:gatewayArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/gateways/:gatewayArn');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/gateways/:gatewayArn' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/gateways/:gatewayArn' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/gateways/:gatewayArn")

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

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

import requests

url = "{{baseUrl}}/v1/gateways/:gatewayArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/gateways/:gatewayArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/gateways/:gatewayArn")

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/v1/gateways/:gatewayArn') do |req|
end

puts response.status
puts response.body

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

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

    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}}/v1/gateways/:gatewayArn

http DELETE {{baseUrl}}/v1/gateways/:gatewayArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/gateways/:gatewayArn

import Foundation

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

{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn

QUERY PARAMS

gatewayInstanceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")

require "http/client"

url = "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"

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

var client = new RestClient("{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"

	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/v1/gateway-instances/:gatewayInstanceArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn'
};

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

const url = '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn';
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}}/v1/gateway-instances/:gatewayInstanceArn',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn');

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}}/v1/gateway-instances/:gatewayInstanceArn'
};

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

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

const url = '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn';
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}}/v1/gateway-instances/:gatewayInstanceArn"]
                                                       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}}/v1/gateway-instances/:gatewayInstanceArn" in

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

 "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn",
  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}}/v1/gateway-instances/:gatewayInstanceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1/gateway-instances/:gatewayInstanceArn")

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

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

import requests

url = "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")

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/v1/gateway-instances/:gatewayInstanceArn') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn";

    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}}/v1/gateway-instances/:gatewayInstanceArn

http DELETE {{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")! 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 DescribeBridge

{{baseUrl}}/v1/bridges/:bridgeArn

QUERY PARAMS

bridgeArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/bridges/:bridgeArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/bridges/:bridgeArn")

require "http/client"

url = "{{baseUrl}}/v1/bridges/:bridgeArn"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/bridges/:bridgeArn"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/bridges/:bridgeArn'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/bridges/:bridgeArn');

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}}/v1/bridges/:bridgeArn'};

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

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

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

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

 "{{baseUrl}}/v1/bridges/:bridgeArn",
  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}}/v1/bridges/:bridgeArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/bridges/:bridgeArn');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/bridges/:bridgeArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/bridges/:bridgeArn' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/bridges/:bridgeArn")

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

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

import requests

url = "{{baseUrl}}/v1/bridges/:bridgeArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges/:bridgeArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/bridges/:bridgeArn")

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/v1/bridges/:bridgeArn') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1/bridges/:bridgeArn

http GET {{baseUrl}}/v1/bridges/:bridgeArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/bridges/:bridgeArn

import Foundation

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

{{baseUrl}}/v1/flows/:flowArn

QUERY PARAMS

flowArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/flows/:flowArn")

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/flows/:flowArn'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/flows/:flowArn');

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}}/v1/flows/:flowArn'};

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

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

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

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

 "{{baseUrl}}/v1/flows/:flowArn",
  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}}/v1/flows/:flowArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/flows/:flowArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/flows/:flowArn")

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

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

import requests

url = "{{baseUrl}}/v1/flows/:flowArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn")

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/v1/flows/:flowArn') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1/flows/:flowArn

http GET {{baseUrl}}/v1/flows/:flowArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn

import Foundation

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

{{baseUrl}}/v1/gateways/:gatewayArn

QUERY PARAMS

gatewayArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/gateways/:gatewayArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/gateways/:gatewayArn")

require "http/client"

url = "{{baseUrl}}/v1/gateways/:gatewayArn"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/gateways/:gatewayArn"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/gateways/:gatewayArn'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/gateways/:gatewayArn")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/gateways/:gatewayArn');

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}}/v1/gateways/:gatewayArn'};

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

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

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

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

 "{{baseUrl}}/v1/gateways/:gatewayArn",
  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}}/v1/gateways/:gatewayArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/gateways/:gatewayArn');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/gateways/:gatewayArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/gateways/:gatewayArn' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/gateways/:gatewayArn")

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

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

import requests

url = "{{baseUrl}}/v1/gateways/:gatewayArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/gateways/:gatewayArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/gateways/:gatewayArn")

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/v1/gateways/:gatewayArn') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1/gateways/:gatewayArn

http GET {{baseUrl}}/v1/gateways/:gatewayArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/gateways/:gatewayArn

import Foundation

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

{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn

QUERY PARAMS

gatewayInstanceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")

require "http/client"

url = "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"

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

var client = new RestClient("{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"

	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/v1/gateway-instances/:gatewayInstanceArn HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn');

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}}/v1/gateway-instances/:gatewayInstanceArn'
};

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

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

const url = '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn';
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}}/v1/gateway-instances/:gatewayInstanceArn"]
                                                       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}}/v1/gateway-instances/:gatewayInstanceArn" in

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

 "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn",
  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}}/v1/gateway-instances/:gatewayInstanceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/gateway-instances/:gatewayInstanceArn")

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

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

import requests

url = "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")

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/v1/gateway-instances/:gatewayInstanceArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn";

    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}}/v1/gateway-instances/:gatewayInstanceArn

http GET {{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")! 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 DescribeOffering

{{baseUrl}}/v1/offerings/:offeringArn

QUERY PARAMS

offeringArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/offerings/:offeringArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/offerings/:offeringArn")

require "http/client"

url = "{{baseUrl}}/v1/offerings/:offeringArn"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/offerings/:offeringArn"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/offerings/:offeringArn'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/offerings/:offeringArn")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/offerings/:offeringArn');

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}}/v1/offerings/:offeringArn'};

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

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

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

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

 "{{baseUrl}}/v1/offerings/:offeringArn",
  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}}/v1/offerings/:offeringArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/offerings/:offeringArn');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/offerings/:offeringArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/offerings/:offeringArn' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/offerings/:offeringArn")

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

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

import requests

url = "{{baseUrl}}/v1/offerings/:offeringArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/offerings/:offeringArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/offerings/:offeringArn")

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/v1/offerings/:offeringArn') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1/offerings/:offeringArn

http GET {{baseUrl}}/v1/offerings/:offeringArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/offerings/:offeringArn

import Foundation

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

{{baseUrl}}/v1/reservations/:reservationArn

QUERY PARAMS

reservationArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/reservations/:reservationArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/reservations/:reservationArn")

require "http/client"

url = "{{baseUrl}}/v1/reservations/:reservationArn"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/reservations/:reservationArn"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1/reservations/:reservationArn'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/reservations/:reservationArn")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/reservations/:reservationArn');

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}}/v1/reservations/:reservationArn'
};

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

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

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

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

 "{{baseUrl}}/v1/reservations/:reservationArn",
  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}}/v1/reservations/:reservationArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/reservations/:reservationArn');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/reservations/:reservationArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/reservations/:reservationArn' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/reservations/:reservationArn")

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

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

import requests

url = "{{baseUrl}}/v1/reservations/:reservationArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/reservations/:reservationArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/reservations/:reservationArn")

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/v1/reservations/:reservationArn') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1/reservations/:reservationArn

http GET {{baseUrl}}/v1/reservations/:reservationArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/reservations/:reservationArn

import Foundation

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

{{baseUrl}}/v1/flows/:flowArn/entitlements

QUERY PARAMS

flowArn

BODY json

{
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/entitlements");

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  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1/flows/:flowArn/entitlements" {:content-type :json
                                                                           :form-params {:entitlements [{:DataTransferSubscriberFeePercent ""
                                                                                                         :Description ""
                                                                                                         :Encryption ""
                                                                                                         :EntitlementStatus ""
                                                                                                         :Name ""
                                                                                                         :Subscribers ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/entitlements"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/flows/:flowArn/entitlements"),
    Content = new StringContent("{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/:flowArn/entitlements");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/entitlements"

	payload := strings.NewReader("{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1/flows/:flowArn/entitlements HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 207

{
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/flows/:flowArn/entitlements")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/entitlements"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/entitlements")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1/flows/:flowArn/entitlements")
  .header("content-type", "application/json")
  .body("{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  entitlements: [
    {
      DataTransferSubscriberFeePercent: '',
      Description: '',
      Encryption: '',
      EntitlementStatus: '',
      Name: '',
      Subscribers: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1/flows/:flowArn/entitlements');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows/:flowArn/entitlements',
  headers: {'content-type': 'application/json'},
  data: {
    entitlements: [
      {
        DataTransferSubscriberFeePercent: '',
        Description: '',
        Encryption: '',
        EntitlementStatus: '',
        Name: '',
        Subscribers: ''
      }
    ]
  }
};

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

const url = '{{baseUrl}}/v1/flows/:flowArn/entitlements';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"entitlements":[{"DataTransferSubscriberFeePercent":"","Description":"","Encryption":"","EntitlementStatus":"","Name":"","Subscribers":""}]}'
};

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}}/v1/flows/:flowArn/entitlements',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "entitlements": [\n    {\n      "DataTransferSubscriberFeePercent": "",\n      "Description": "",\n      "Encryption": "",\n      "EntitlementStatus": "",\n      "Name": "",\n      "Subscribers": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/entitlements")
  .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/v1/flows/:flowArn/entitlements',
  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({
  entitlements: [
    {
      DataTransferSubscriberFeePercent: '',
      Description: '',
      Encryption: '',
      EntitlementStatus: '',
      Name: '',
      Subscribers: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/flows/:flowArn/entitlements',
  headers: {'content-type': 'application/json'},
  body: {
    entitlements: [
      {
        DataTransferSubscriberFeePercent: '',
        Description: '',
        Encryption: '',
        EntitlementStatus: '',
        Name: '',
        Subscribers: ''
      }
    ]
  },
  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}}/v1/flows/:flowArn/entitlements');

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

req.type('json');
req.send({
  entitlements: [
    {
      DataTransferSubscriberFeePercent: '',
      Description: '',
      Encryption: '',
      EntitlementStatus: '',
      Name: '',
      Subscribers: ''
    }
  ]
});

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}}/v1/flows/:flowArn/entitlements',
  headers: {'content-type': 'application/json'},
  data: {
    entitlements: [
      {
        DataTransferSubscriberFeePercent: '',
        Description: '',
        Encryption: '',
        EntitlementStatus: '',
        Name: '',
        Subscribers: ''
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/v1/flows/:flowArn/entitlements';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"entitlements":[{"DataTransferSubscriberFeePercent":"","Description":"","Encryption":"","EntitlementStatus":"","Name":"","Subscribers":""}]}'
};

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 = @{ @"entitlements": @[ @{ @"DataTransferSubscriberFeePercent": @"", @"Description": @"", @"Encryption": @"", @"EntitlementStatus": @"", @"Name": @"", @"Subscribers": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/:flowArn/entitlements"]
                                                       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}}/v1/flows/:flowArn/entitlements" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1/flows/:flowArn/entitlements",
  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([
    'entitlements' => [
        [
                'DataTransferSubscriberFeePercent' => '',
                'Description' => '',
                'Encryption' => '',
                'EntitlementStatus' => '',
                'Name' => '',
                'Subscribers' => ''
        ]
    ]
  ]),
  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}}/v1/flows/:flowArn/entitlements', [
  'body' => '{
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/entitlements');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'entitlements' => [
    [
        'DataTransferSubscriberFeePercent' => '',
        'Description' => '',
        'Encryption' => '',
        'EntitlementStatus' => '',
        'Name' => '',
        'Subscribers' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'entitlements' => [
    [
        'DataTransferSubscriberFeePercent' => '',
        'Description' => '',
        'Encryption' => '',
        'EntitlementStatus' => '',
        'Name' => '',
        'Subscribers' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/entitlements');
$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}}/v1/flows/:flowArn/entitlements' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/entitlements' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1/flows/:flowArn/entitlements", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/entitlements"

payload = { "entitlements": [
        {
            "DataTransferSubscriberFeePercent": "",
            "Description": "",
            "Encryption": "",
            "EntitlementStatus": "",
            "Name": "",
            "Subscribers": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/entitlements"

payload <- "{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/entitlements")

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  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1/flows/:flowArn/entitlements') do |req|
  req.body = "{\n  \"entitlements\": [\n    {\n      \"DataTransferSubscriberFeePercent\": \"\",\n      \"Description\": \"\",\n      \"Encryption\": \"\",\n      \"EntitlementStatus\": \"\",\n      \"Name\": \"\",\n      \"Subscribers\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"entitlements": (
            json!({
                "DataTransferSubscriberFeePercent": "",
                "Description": "",
                "Encryption": "",
                "EntitlementStatus": "",
                "Name": "",
                "Subscribers": ""
            })
        )});

    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}}/v1/flows/:flowArn/entitlements \
  --header 'content-type: application/json' \
  --data '{
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ]
}'

echo '{
  "entitlements": [
    {
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/flows/:flowArn/entitlements \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "entitlements": [\n    {\n      "DataTransferSubscriberFeePercent": "",\n      "Description": "",\n      "Encryption": "",\n      "EntitlementStatus": "",\n      "Name": "",\n      "Subscribers": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/entitlements

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["entitlements": [
    [
      "DataTransferSubscriberFeePercent": "",
      "Description": "",
      "Encryption": "",
      "EntitlementStatus": "",
      "Name": "",
      "Subscribers": ""
    ]
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/entitlements")! 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 ListBridges

{{baseUrl}}/v1/bridges

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/bridges")

require "http/client"

url = "{{baseUrl}}/v1/bridges"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/bridges"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/bridges")

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

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

import requests

url = "{{baseUrl}}/v1/bridges"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/bridges")

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

puts response.status
puts response.body

use reqwest;

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

    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}}/v1/bridges

http GET {{baseUrl}}/v1/bridges

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

import Foundation

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

{{baseUrl}}/v1/entitlements

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/entitlements")

require "http/client"

url = "{{baseUrl}}/v1/entitlements"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/entitlements"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/entitlements")

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

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

import requests

url = "{{baseUrl}}/v1/entitlements"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/entitlements"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/entitlements")

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

puts response.status
puts response.body

use reqwest;

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

    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}}/v1/entitlements

http GET {{baseUrl}}/v1/entitlements

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

import Foundation

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

{{baseUrl}}/v1/flows

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/flows")

require "http/client"

url = "{{baseUrl}}/v1/flows"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/flows"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/flows")

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

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

import requests

url = "{{baseUrl}}/v1/flows"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows")

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

puts response.status
puts response.body

use reqwest;

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

    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}}/v1/flows

http GET {{baseUrl}}/v1/flows

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

import Foundation

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

{{baseUrl}}/v1/gateway-instances

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/gateway-instances");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/gateway-instances")

require "http/client"

url = "{{baseUrl}}/v1/gateway-instances"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/gateway-instances"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/gateway-instances'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/gateway-instances")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/gateway-instances');

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}}/v1/gateway-instances'};

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/gateway-instances');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/gateway-instances' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/gateway-instances' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1/gateway-instances")

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

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

import requests

url = "{{baseUrl}}/v1/gateway-instances"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/gateway-instances"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/gateway-instances")

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/v1/gateway-instances') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1/gateway-instances

http GET {{baseUrl}}/v1/gateway-instances

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/gateway-instances

import Foundation

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

{{baseUrl}}/v1/gateways

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/gateways")

require "http/client"

url = "{{baseUrl}}/v1/gateways"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/gateways"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1/gateways")

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

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

import requests

url = "{{baseUrl}}/v1/gateways"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/gateways"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/gateways")

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

puts response.status
puts response.body

use reqwest;

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

    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}}/v1/gateways

http GET {{baseUrl}}/v1/gateways

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

import Foundation

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

{{baseUrl}}/v1/offerings

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1/offerings")

require "http/client"

url = "{{baseUrl}}/v1/offerings"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1/offerings"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1/offerings');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/offerings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/offerings' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/offerings' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/offerings")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/offerings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/offerings"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/offerings")

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/v1/offerings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/offerings";

    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}}/v1/offerings

http GET {{baseUrl}}/v1/offerings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/offerings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/offerings")! 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 ListReservations

{{baseUrl}}/v1/reservations

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/reservations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/reservations")

require "http/client"

url = "{{baseUrl}}/v1/reservations"

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}}/v1/reservations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/reservations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/reservations"

	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/v1/reservations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/reservations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/reservations"))
    .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}}/v1/reservations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/reservations")
  .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}}/v1/reservations');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/reservations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/reservations';
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}}/v1/reservations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/reservations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/reservations',
  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}}/v1/reservations'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/reservations');

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}}/v1/reservations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/reservations';
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}}/v1/reservations"]
                                                       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}}/v1/reservations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/reservations",
  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}}/v1/reservations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/reservations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/reservations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/reservations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/reservations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/reservations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/reservations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/reservations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/reservations")

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/v1/reservations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/reservations";

    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}}/v1/reservations

http GET {{baseUrl}}/v1/reservations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/reservations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/reservations")! 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 PurchaseOffering

{{baseUrl}}/v1/offerings/:offeringArn

QUERY PARAMS

offeringArn

BODY json

{
  "reservationName": "",
  "start": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/offerings/:offeringArn");

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  \"reservationName\": \"\",\n  \"start\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/offerings/:offeringArn" {:content-type :json
                                                                      :form-params {:reservationName ""
                                                                                    :start ""}})

require "http/client"

url = "{{baseUrl}}/v1/offerings/:offeringArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"reservationName\": \"\",\n  \"start\": \"\"\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}}/v1/offerings/:offeringArn"),
    Content = new StringContent("{\n  \"reservationName\": \"\",\n  \"start\": \"\"\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}}/v1/offerings/:offeringArn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"reservationName\": \"\",\n  \"start\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/offerings/:offeringArn"

	payload := strings.NewReader("{\n  \"reservationName\": \"\",\n  \"start\": \"\"\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/v1/offerings/:offeringArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "reservationName": "",
  "start": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/offerings/:offeringArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"reservationName\": \"\",\n  \"start\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/offerings/:offeringArn"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"reservationName\": \"\",\n  \"start\": \"\"\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  \"reservationName\": \"\",\n  \"start\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/offerings/:offeringArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/offerings/:offeringArn")
  .header("content-type", "application/json")
  .body("{\n  \"reservationName\": \"\",\n  \"start\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  reservationName: '',
  start: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/offerings/:offeringArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/offerings/:offeringArn',
  headers: {'content-type': 'application/json'},
  data: {reservationName: '', start: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/offerings/:offeringArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"reservationName":"","start":""}'
};

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}}/v1/offerings/:offeringArn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "reservationName": "",\n  "start": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"reservationName\": \"\",\n  \"start\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/offerings/:offeringArn")
  .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/v1/offerings/:offeringArn',
  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({reservationName: '', start: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/offerings/:offeringArn',
  headers: {'content-type': 'application/json'},
  body: {reservationName: '', start: ''},
  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}}/v1/offerings/:offeringArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  reservationName: '',
  start: ''
});

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}}/v1/offerings/:offeringArn',
  headers: {'content-type': 'application/json'},
  data: {reservationName: '', start: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/offerings/:offeringArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"reservationName":"","start":""}'
};

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 = @{ @"reservationName": @"",
                              @"start": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/offerings/:offeringArn"]
                                                       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}}/v1/offerings/:offeringArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"reservationName\": \"\",\n  \"start\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/offerings/:offeringArn",
  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([
    'reservationName' => '',
    'start' => ''
  ]),
  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}}/v1/offerings/:offeringArn', [
  'body' => '{
  "reservationName": "",
  "start": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/offerings/:offeringArn');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'reservationName' => '',
  'start' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'reservationName' => '',
  'start' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/offerings/:offeringArn');
$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}}/v1/offerings/:offeringArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "reservationName": "",
  "start": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/offerings/:offeringArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "reservationName": "",
  "start": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"reservationName\": \"\",\n  \"start\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/offerings/:offeringArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/offerings/:offeringArn"

payload = {
    "reservationName": "",
    "start": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/offerings/:offeringArn"

payload <- "{\n  \"reservationName\": \"\",\n  \"start\": \"\"\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}}/v1/offerings/:offeringArn")

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  \"reservationName\": \"\",\n  \"start\": \"\"\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/v1/offerings/:offeringArn') do |req|
  req.body = "{\n  \"reservationName\": \"\",\n  \"start\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/offerings/:offeringArn";

    let payload = json!({
        "reservationName": "",
        "start": ""
    });

    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}}/v1/offerings/:offeringArn \
  --header 'content-type: application/json' \
  --data '{
  "reservationName": "",
  "start": ""
}'

echo '{
  "reservationName": "",
  "start": ""
}' |  \
  http POST {{baseUrl}}/v1/offerings/:offeringArn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "reservationName": "",\n  "start": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/offerings/:offeringArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "reservationName": "",
  "start": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/offerings/:offeringArn")! 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 RemoveBridgeOutput

{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName

QUERY PARAMS

bridgeArn

outputName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")

require "http/client"

url = "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"

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}}/v1/bridges/:bridgeArn/outputs/:outputName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"

	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/v1/bridges/:bridgeArn/outputs/:outputName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"))
    .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}}/v1/bridges/:bridgeArn/outputs/:outputName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")
  .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}}/v1/bridges/:bridgeArn/outputs/:outputName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName';
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}}/v1/bridges/:bridgeArn/outputs/:outputName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/bridges/:bridgeArn/outputs/:outputName',
  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}}/v1/bridges/:bridgeArn/outputs/:outputName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName');

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}}/v1/bridges/:bridgeArn/outputs/:outputName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName';
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}}/v1/bridges/:bridgeArn/outputs/:outputName"]
                                                       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}}/v1/bridges/:bridgeArn/outputs/:outputName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName",
  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}}/v1/bridges/:bridgeArn/outputs/:outputName');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/bridges/:bridgeArn/outputs/:outputName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")

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/v1/bridges/:bridgeArn/outputs/:outputName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName";

    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}}/v1/bridges/:bridgeArn/outputs/:outputName

http DELETE {{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")! 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 RemoveBridgeSource

{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName

QUERY PARAMS

bridgeArn

sourceName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")

require "http/client"

url = "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"

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}}/v1/bridges/:bridgeArn/sources/:sourceName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"

	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/v1/bridges/:bridgeArn/sources/:sourceName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"))
    .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}}/v1/bridges/:bridgeArn/sources/:sourceName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")
  .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}}/v1/bridges/:bridgeArn/sources/:sourceName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName';
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}}/v1/bridges/:bridgeArn/sources/:sourceName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/bridges/:bridgeArn/sources/:sourceName',
  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}}/v1/bridges/:bridgeArn/sources/:sourceName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName');

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}}/v1/bridges/:bridgeArn/sources/:sourceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName';
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}}/v1/bridges/:bridgeArn/sources/:sourceName"]
                                                       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}}/v1/bridges/:bridgeArn/sources/:sourceName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName",
  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}}/v1/bridges/:bridgeArn/sources/:sourceName');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/bridges/:bridgeArn/sources/:sourceName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")

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/v1/bridges/:bridgeArn/sources/:sourceName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName";

    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}}/v1/bridges/:bridgeArn/sources/:sourceName

http DELETE {{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")! 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 RemoveFlowMediaStream

{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName

QUERY PARAMS

flowArn

mediaStreamName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"

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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"

	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/v1/flows/:flowArn/mediaStreams/:mediaStreamName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"))
    .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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")
  .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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName';
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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/flows/:flowArn/mediaStreams/:mediaStreamName',
  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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName');

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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName';
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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"]
                                                       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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName",
  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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/flows/:flowArn/mediaStreams/:mediaStreamName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")

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/v1/flows/:flowArn/mediaStreams/:mediaStreamName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName";

    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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName

http DELETE {{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")! 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 RemoveFlowOutput

{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn

QUERY PARAMS

flowArn

outputArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"

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}}/v1/flows/:flowArn/outputs/:outputArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"

	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/v1/flows/:flowArn/outputs/:outputArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"))
    .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}}/v1/flows/:flowArn/outputs/:outputArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")
  .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}}/v1/flows/:flowArn/outputs/:outputArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn';
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}}/v1/flows/:flowArn/outputs/:outputArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/flows/:flowArn/outputs/:outputArn',
  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}}/v1/flows/:flowArn/outputs/:outputArn'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn');

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}}/v1/flows/:flowArn/outputs/:outputArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn';
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}}/v1/flows/:flowArn/outputs/:outputArn"]
                                                       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}}/v1/flows/:flowArn/outputs/:outputArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn",
  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}}/v1/flows/:flowArn/outputs/:outputArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/flows/:flowArn/outputs/:outputArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")

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/v1/flows/:flowArn/outputs/:outputArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn";

    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}}/v1/flows/:flowArn/outputs/:outputArn

http DELETE {{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")! 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 RemoveFlowSource

{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn

QUERY PARAMS

flowArn

sourceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"

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}}/v1/flows/:flowArn/source/:sourceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"

	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/v1/flows/:flowArn/source/:sourceArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"))
    .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}}/v1/flows/:flowArn/source/:sourceArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")
  .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}}/v1/flows/:flowArn/source/:sourceArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn';
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}}/v1/flows/:flowArn/source/:sourceArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/flows/:flowArn/source/:sourceArn',
  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}}/v1/flows/:flowArn/source/:sourceArn'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn');

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}}/v1/flows/:flowArn/source/:sourceArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn';
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}}/v1/flows/:flowArn/source/:sourceArn"]
                                                       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}}/v1/flows/:flowArn/source/:sourceArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn",
  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}}/v1/flows/:flowArn/source/:sourceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/flows/:flowArn/source/:sourceArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")

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/v1/flows/:flowArn/source/:sourceArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn";

    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}}/v1/flows/:flowArn/source/:sourceArn

http DELETE {{baseUrl}}/v1/flows/:flowArn/source/:sourceArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/source/:sourceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")! 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 RemoveFlowVpcInterface

{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName

QUERY PARAMS

flowArn

vpcInterfaceName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName")

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName"

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}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName"

	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/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName"))
    .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}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName")
  .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}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName';
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}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName',
  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}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName');

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}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName';
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}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName"]
                                                       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}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName",
  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}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName")

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/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName";

    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}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName

http DELETE {{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/vpcInterfaces/:vpcInterfaceName")! 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 RevokeFlowEntitlement

{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn

QUERY PARAMS

entitlementArn

flowArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn")

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn"

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}}/v1/flows/:flowArn/entitlements/:entitlementArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn"

	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/v1/flows/:flowArn/entitlements/:entitlementArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn"))
    .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}}/v1/flows/:flowArn/entitlements/:entitlementArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn")
  .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}}/v1/flows/:flowArn/entitlements/:entitlementArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn';
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}}/v1/flows/:flowArn/entitlements/:entitlementArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/flows/:flowArn/entitlements/:entitlementArn',
  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}}/v1/flows/:flowArn/entitlements/:entitlementArn'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn');

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}}/v1/flows/:flowArn/entitlements/:entitlementArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn';
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}}/v1/flows/:flowArn/entitlements/:entitlementArn"]
                                                       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}}/v1/flows/:flowArn/entitlements/:entitlementArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn",
  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}}/v1/flows/:flowArn/entitlements/:entitlementArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/flows/:flowArn/entitlements/:entitlementArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn")

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/v1/flows/:flowArn/entitlements/:entitlementArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn";

    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}}/v1/flows/:flowArn/entitlements/:entitlementArn

http DELETE {{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn")! 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 StartFlow

{{baseUrl}}/v1/flows/start/:flowArn

QUERY PARAMS

flowArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/start/:flowArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/flows/start/:flowArn")

require "http/client"

url = "{{baseUrl}}/v1/flows/start/:flowArn"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/flows/start/:flowArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/start/:flowArn");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/start/:flowArn"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/flows/start/:flowArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/flows/start/:flowArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/start/:flowArn"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/start/:flowArn")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/flows/start/:flowArn")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/flows/start/:flowArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/v1/flows/start/:flowArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/start/:flowArn';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/flows/start/:flowArn',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/start/:flowArn")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/flows/start/:flowArn',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/v1/flows/start/:flowArn'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/flows/start/:flowArn');

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}}/v1/flows/start/:flowArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/start/:flowArn';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/start/:flowArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/flows/start/:flowArn" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/start/:flowArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/flows/start/:flowArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/start/:flowArn');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/flows/start/:flowArn');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/flows/start/:flowArn' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/start/:flowArn' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v1/flows/start/:flowArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/start/:flowArn"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/start/:flowArn"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/start/:flowArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v1/flows/start/:flowArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/flows/start/:flowArn";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/flows/start/:flowArn

http POST {{baseUrl}}/v1/flows/start/:flowArn

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v1/flows/start/:flowArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/start/:flowArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StopFlow

{{baseUrl}}/v1/flows/stop/:flowArn

QUERY PARAMS

flowArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/stop/:flowArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/flows/stop/:flowArn")

require "http/client"

url = "{{baseUrl}}/v1/flows/stop/:flowArn"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/flows/stop/:flowArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/flows/stop/:flowArn");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/stop/:flowArn"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/flows/stop/:flowArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/flows/stop/:flowArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/stop/:flowArn"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/stop/:flowArn")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/flows/stop/:flowArn")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/flows/stop/:flowArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/v1/flows/stop/:flowArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/stop/:flowArn';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/flows/stop/:flowArn',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/stop/:flowArn")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/flows/stop/:flowArn',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/v1/flows/stop/:flowArn'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/flows/stop/:flowArn');

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}}/v1/flows/stop/:flowArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/stop/:flowArn';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/stop/:flowArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/flows/stop/:flowArn" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/stop/:flowArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/flows/stop/:flowArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/stop/:flowArn');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/flows/stop/:flowArn');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/flows/stop/:flowArn' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/stop/:flowArn' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v1/flows/stop/:flowArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/stop/:flowArn"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/stop/:flowArn"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/stop/:flowArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v1/flows/stop/:flowArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/flows/stop/:flowArn";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1/flows/stop/:flowArn

http POST {{baseUrl}}/v1/flows/stop/:flowArn

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v1/flows/stop/:flowArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/stop/:flowArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

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 UpdateBridge

{{baseUrl}}/v1/bridges/:bridgeArn

QUERY PARAMS

bridgeArn

BODY json

{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/bridges/:bridgeArn");

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  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v1/bridges/:bridgeArn" {:content-type :json
                                                                 :form-params {:egressGatewayBridge {:MaxBitrate ""}
                                                                               :ingressGatewayBridge {:MaxBitrate ""
                                                                                                      :MaxOutputs ""}
                                                                               :sourceFailoverConfig {:FailoverMode ""
                                                                                                      :RecoveryWindow ""
                                                                                                      :SourcePriority ""
                                                                                                      :State ""}}})

require "http/client"

url = "{{baseUrl}}/v1/bridges/:bridgeArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v1/bridges/:bridgeArn"),
    Content = new StringContent("{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\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}}/v1/bridges/:bridgeArn");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/bridges/:bridgeArn"

	payload := strings.NewReader("{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v1/bridges/:bridgeArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 256

{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/bridges/:bridgeArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/bridges/:bridgeArn"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\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  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v1/bridges/:bridgeArn")
  .header("content-type", "application/json")
  .body("{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  egressGatewayBridge: {
    MaxBitrate: ''
  },
  ingressGatewayBridge: {
    MaxBitrate: '',
    MaxOutputs: ''
  },
  sourceFailoverConfig: {
    FailoverMode: '',
    RecoveryWindow: '',
    SourcePriority: '',
    State: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v1/bridges/:bridgeArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn',
  headers: {'content-type': 'application/json'},
  data: {
    egressGatewayBridge: {MaxBitrate: ''},
    ingressGatewayBridge: {MaxBitrate: '', MaxOutputs: ''},
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/bridges/:bridgeArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"egressGatewayBridge":{"MaxBitrate":""},"ingressGatewayBridge":{"MaxBitrate":"","MaxOutputs":""},"sourceFailoverConfig":{"FailoverMode":"","RecoveryWindow":"","SourcePriority":"","State":""}}'
};

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}}/v1/bridges/:bridgeArn',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "egressGatewayBridge": {\n    "MaxBitrate": ""\n  },\n  "ingressGatewayBridge": {\n    "MaxBitrate": "",\n    "MaxOutputs": ""\n  },\n  "sourceFailoverConfig": {\n    "FailoverMode": "",\n    "RecoveryWindow": "",\n    "SourcePriority": "",\n    "State": ""\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  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn")
  .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/v1/bridges/:bridgeArn',
  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({
  egressGatewayBridge: {MaxBitrate: ''},
  ingressGatewayBridge: {MaxBitrate: '', MaxOutputs: ''},
  sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn',
  headers: {'content-type': 'application/json'},
  body: {
    egressGatewayBridge: {MaxBitrate: ''},
    ingressGatewayBridge: {MaxBitrate: '', MaxOutputs: ''},
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''}
  },
  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}}/v1/bridges/:bridgeArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  egressGatewayBridge: {
    MaxBitrate: ''
  },
  ingressGatewayBridge: {
    MaxBitrate: '',
    MaxOutputs: ''
  },
  sourceFailoverConfig: {
    FailoverMode: '',
    RecoveryWindow: '',
    SourcePriority: '',
    State: ''
  }
});

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}}/v1/bridges/:bridgeArn',
  headers: {'content-type': 'application/json'},
  data: {
    egressGatewayBridge: {MaxBitrate: ''},
    ingressGatewayBridge: {MaxBitrate: '', MaxOutputs: ''},
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/bridges/:bridgeArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"egressGatewayBridge":{"MaxBitrate":""},"ingressGatewayBridge":{"MaxBitrate":"","MaxOutputs":""},"sourceFailoverConfig":{"FailoverMode":"","RecoveryWindow":"","SourcePriority":"","State":""}}'
};

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 = @{ @"egressGatewayBridge": @{ @"MaxBitrate": @"" },
                              @"ingressGatewayBridge": @{ @"MaxBitrate": @"", @"MaxOutputs": @"" },
                              @"sourceFailoverConfig": @{ @"FailoverMode": @"", @"RecoveryWindow": @"", @"SourcePriority": @"", @"State": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/bridges/:bridgeArn"]
                                                       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}}/v1/bridges/:bridgeArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/bridges/:bridgeArn",
  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([
    'egressGatewayBridge' => [
        'MaxBitrate' => ''
    ],
    'ingressGatewayBridge' => [
        'MaxBitrate' => '',
        'MaxOutputs' => ''
    ],
    'sourceFailoverConfig' => [
        'FailoverMode' => '',
        'RecoveryWindow' => '',
        'SourcePriority' => '',
        'State' => ''
    ]
  ]),
  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}}/v1/bridges/:bridgeArn', [
  'body' => '{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/bridges/:bridgeArn');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'egressGatewayBridge' => [
    'MaxBitrate' => ''
  ],
  'ingressGatewayBridge' => [
    'MaxBitrate' => '',
    'MaxOutputs' => ''
  ],
  'sourceFailoverConfig' => [
    'FailoverMode' => '',
    'RecoveryWindow' => '',
    'SourcePriority' => '',
    'State' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'egressGatewayBridge' => [
    'MaxBitrate' => ''
  ],
  'ingressGatewayBridge' => [
    'MaxBitrate' => '',
    'MaxOutputs' => ''
  ],
  'sourceFailoverConfig' => [
    'FailoverMode' => '',
    'RecoveryWindow' => '',
    'SourcePriority' => '',
    'State' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/bridges/:bridgeArn');
$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}}/v1/bridges/:bridgeArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/bridges/:bridgeArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v1/bridges/:bridgeArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/bridges/:bridgeArn"

payload = {
    "egressGatewayBridge": { "MaxBitrate": "" },
    "ingressGatewayBridge": {
        "MaxBitrate": "",
        "MaxOutputs": ""
    },
    "sourceFailoverConfig": {
        "FailoverMode": "",
        "RecoveryWindow": "",
        "SourcePriority": "",
        "State": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges/:bridgeArn"

payload <- "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/bridges/:bridgeArn")

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  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/v1/bridges/:bridgeArn') do |req|
  req.body = "{\n  \"egressGatewayBridge\": {\n    \"MaxBitrate\": \"\"\n  },\n  \"ingressGatewayBridge\": {\n    \"MaxBitrate\": \"\",\n    \"MaxOutputs\": \"\"\n  },\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/bridges/:bridgeArn";

    let payload = json!({
        "egressGatewayBridge": json!({"MaxBitrate": ""}),
        "ingressGatewayBridge": json!({
            "MaxBitrate": "",
            "MaxOutputs": ""
        }),
        "sourceFailoverConfig": json!({
            "FailoverMode": "",
            "RecoveryWindow": "",
            "SourcePriority": "",
            "State": ""
        })
    });

    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}}/v1/bridges/:bridgeArn \
  --header 'content-type: application/json' \
  --data '{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  }
}'

echo '{
  "egressGatewayBridge": {
    "MaxBitrate": ""
  },
  "ingressGatewayBridge": {
    "MaxBitrate": "",
    "MaxOutputs": ""
  },
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  }
}' |  \
  http PUT {{baseUrl}}/v1/bridges/:bridgeArn \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "egressGatewayBridge": {\n    "MaxBitrate": ""\n  },\n  "ingressGatewayBridge": {\n    "MaxBitrate": "",\n    "MaxOutputs": ""\n  },\n  "sourceFailoverConfig": {\n    "FailoverMode": "",\n    "RecoveryWindow": "",\n    "SourcePriority": "",\n    "State": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/bridges/:bridgeArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "egressGatewayBridge": ["MaxBitrate": ""],
  "ingressGatewayBridge": [
    "MaxBitrate": "",
    "MaxOutputs": ""
  ],
  "sourceFailoverConfig": [
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/bridges/:bridgeArn")! 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 UpdateBridgeOutput

{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName

QUERY PARAMS

bridgeArn

outputName

BODY json

{
  "networkOutput": {
    "IpAddress": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": "",
    "Ttl": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName");

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  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName" {:content-type :json
                                                                                     :form-params {:networkOutput {:IpAddress ""
                                                                                                                   :NetworkName ""
                                                                                                                   :Port ""
                                                                                                                   :Protocol ""
                                                                                                                   :Ttl ""}}})

require "http/client"

url = "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"),
    Content = new StringContent("{\n  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\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}}/v1/bridges/:bridgeArn/outputs/:outputName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"

	payload := strings.NewReader("{\n  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v1/bridges/:bridgeArn/outputs/:outputName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 122

{
  "networkOutput": {
    "IpAddress": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": "",
    "Ttl": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\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  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")
  .header("content-type", "application/json")
  .body("{\n  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  networkOutput: {
    IpAddress: '',
    NetworkName: '',
    Port: '',
    Protocol: '',
    Ttl: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName',
  headers: {'content-type': 'application/json'},
  data: {
    networkOutput: {IpAddress: '', NetworkName: '', Port: '', Protocol: '', Ttl: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"networkOutput":{"IpAddress":"","NetworkName":"","Port":"","Protocol":"","Ttl":""}}'
};

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}}/v1/bridges/:bridgeArn/outputs/:outputName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "networkOutput": {\n    "IpAddress": "",\n    "NetworkName": "",\n    "Port": "",\n    "Protocol": "",\n    "Ttl": ""\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  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")
  .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/v1/bridges/:bridgeArn/outputs/:outputName',
  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({
  networkOutput: {IpAddress: '', NetworkName: '', Port: '', Protocol: '', Ttl: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName',
  headers: {'content-type': 'application/json'},
  body: {
    networkOutput: {IpAddress: '', NetworkName: '', Port: '', Protocol: '', Ttl: ''}
  },
  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}}/v1/bridges/:bridgeArn/outputs/:outputName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  networkOutput: {
    IpAddress: '',
    NetworkName: '',
    Port: '',
    Protocol: '',
    Ttl: ''
  }
});

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}}/v1/bridges/:bridgeArn/outputs/:outputName',
  headers: {'content-type': 'application/json'},
  data: {
    networkOutput: {IpAddress: '', NetworkName: '', Port: '', Protocol: '', Ttl: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"networkOutput":{"IpAddress":"","NetworkName":"","Port":"","Protocol":"","Ttl":""}}'
};

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 = @{ @"networkOutput": @{ @"IpAddress": @"", @"NetworkName": @"", @"Port": @"", @"Protocol": @"", @"Ttl": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"]
                                                       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}}/v1/bridges/:bridgeArn/outputs/:outputName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName",
  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([
    'networkOutput' => [
        'IpAddress' => '',
        'NetworkName' => '',
        'Port' => '',
        'Protocol' => '',
        'Ttl' => ''
    ]
  ]),
  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}}/v1/bridges/:bridgeArn/outputs/:outputName', [
  'body' => '{
  "networkOutput": {
    "IpAddress": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": "",
    "Ttl": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'networkOutput' => [
    'IpAddress' => '',
    'NetworkName' => '',
    'Port' => '',
    'Protocol' => '',
    'Ttl' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'networkOutput' => [
    'IpAddress' => '',
    'NetworkName' => '',
    'Port' => '',
    'Protocol' => '',
    'Ttl' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName');
$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}}/v1/bridges/:bridgeArn/outputs/:outputName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "networkOutput": {
    "IpAddress": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": "",
    "Ttl": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "networkOutput": {
    "IpAddress": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": "",
    "Ttl": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v1/bridges/:bridgeArn/outputs/:outputName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"

payload = { "networkOutput": {
        "IpAddress": "",
        "NetworkName": "",
        "Port": "",
        "Protocol": "",
        "Ttl": ""
    } }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName"

payload <- "{\n  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")

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  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/v1/bridges/:bridgeArn/outputs/:outputName') do |req|
  req.body = "{\n  \"networkOutput\": {\n    \"IpAddress\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\",\n    \"Ttl\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName";

    let payload = json!({"networkOutput": json!({
            "IpAddress": "",
            "NetworkName": "",
            "Port": "",
            "Protocol": "",
            "Ttl": ""
        })});

    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}}/v1/bridges/:bridgeArn/outputs/:outputName \
  --header 'content-type: application/json' \
  --data '{
  "networkOutput": {
    "IpAddress": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": "",
    "Ttl": ""
  }
}'

echo '{
  "networkOutput": {
    "IpAddress": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": "",
    "Ttl": ""
  }
}' |  \
  http PUT {{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "networkOutput": {\n    "IpAddress": "",\n    "NetworkName": "",\n    "Port": "",\n    "Protocol": "",\n    "Ttl": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["networkOutput": [
    "IpAddress": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": "",
    "Ttl": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/bridges/:bridgeArn/outputs/:outputName")! 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 UpdateBridgeSource

{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName

QUERY PARAMS

bridgeArn

sourceName

BODY json

{
  "flowSource": {
    "FlowArn": "",
    "FlowVpcInterfaceAttachment": ""
  },
  "networkSource": {
    "MulticastIp": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName");

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  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName" {:content-type :json
                                                                                     :form-params {:flowSource {:FlowArn ""
                                                                                                                :FlowVpcInterfaceAttachment ""}
                                                                                                   :networkSource {:MulticastIp ""
                                                                                                                   :NetworkName ""
                                                                                                                   :Port ""
                                                                                                                   :Protocol ""}}})

require "http/client"

url = "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"),
    Content = new StringContent("{\n  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\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}}/v1/bridges/:bridgeArn/sources/:sourceName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"

	payload := strings.NewReader("{\n  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v1/bridges/:bridgeArn/sources/:sourceName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 188

{
  "flowSource": {
    "FlowArn": "",
    "FlowVpcInterfaceAttachment": ""
  },
  "networkSource": {
    "MulticastIp": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\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  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")
  .header("content-type", "application/json")
  .body("{\n  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  flowSource: {
    FlowArn: '',
    FlowVpcInterfaceAttachment: ''
  },
  networkSource: {
    MulticastIp: '',
    NetworkName: '',
    Port: '',
    Protocol: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName',
  headers: {'content-type': 'application/json'},
  data: {
    flowSource: {FlowArn: '', FlowVpcInterfaceAttachment: ''},
    networkSource: {MulticastIp: '', NetworkName: '', Port: '', Protocol: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"flowSource":{"FlowArn":"","FlowVpcInterfaceAttachment":""},"networkSource":{"MulticastIp":"","NetworkName":"","Port":"","Protocol":""}}'
};

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}}/v1/bridges/:bridgeArn/sources/:sourceName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "flowSource": {\n    "FlowArn": "",\n    "FlowVpcInterfaceAttachment": ""\n  },\n  "networkSource": {\n    "MulticastIp": "",\n    "NetworkName": "",\n    "Port": "",\n    "Protocol": ""\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  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")
  .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/v1/bridges/:bridgeArn/sources/:sourceName',
  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({
  flowSource: {FlowArn: '', FlowVpcInterfaceAttachment: ''},
  networkSource: {MulticastIp: '', NetworkName: '', Port: '', Protocol: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName',
  headers: {'content-type': 'application/json'},
  body: {
    flowSource: {FlowArn: '', FlowVpcInterfaceAttachment: ''},
    networkSource: {MulticastIp: '', NetworkName: '', Port: '', Protocol: ''}
  },
  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}}/v1/bridges/:bridgeArn/sources/:sourceName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  flowSource: {
    FlowArn: '',
    FlowVpcInterfaceAttachment: ''
  },
  networkSource: {
    MulticastIp: '',
    NetworkName: '',
    Port: '',
    Protocol: ''
  }
});

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}}/v1/bridges/:bridgeArn/sources/:sourceName',
  headers: {'content-type': 'application/json'},
  data: {
    flowSource: {FlowArn: '', FlowVpcInterfaceAttachment: ''},
    networkSource: {MulticastIp: '', NetworkName: '', Port: '', Protocol: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"flowSource":{"FlowArn":"","FlowVpcInterfaceAttachment":""},"networkSource":{"MulticastIp":"","NetworkName":"","Port":"","Protocol":""}}'
};

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 = @{ @"flowSource": @{ @"FlowArn": @"", @"FlowVpcInterfaceAttachment": @"" },
                              @"networkSource": @{ @"MulticastIp": @"", @"NetworkName": @"", @"Port": @"", @"Protocol": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"]
                                                       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}}/v1/bridges/:bridgeArn/sources/:sourceName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName",
  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([
    'flowSource' => [
        'FlowArn' => '',
        'FlowVpcInterfaceAttachment' => ''
    ],
    'networkSource' => [
        'MulticastIp' => '',
        'NetworkName' => '',
        'Port' => '',
        'Protocol' => ''
    ]
  ]),
  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}}/v1/bridges/:bridgeArn/sources/:sourceName', [
  'body' => '{
  "flowSource": {
    "FlowArn": "",
    "FlowVpcInterfaceAttachment": ""
  },
  "networkSource": {
    "MulticastIp": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'flowSource' => [
    'FlowArn' => '',
    'FlowVpcInterfaceAttachment' => ''
  ],
  'networkSource' => [
    'MulticastIp' => '',
    'NetworkName' => '',
    'Port' => '',
    'Protocol' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'flowSource' => [
    'FlowArn' => '',
    'FlowVpcInterfaceAttachment' => ''
  ],
  'networkSource' => [
    'MulticastIp' => '',
    'NetworkName' => '',
    'Port' => '',
    'Protocol' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName');
$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}}/v1/bridges/:bridgeArn/sources/:sourceName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "flowSource": {
    "FlowArn": "",
    "FlowVpcInterfaceAttachment": ""
  },
  "networkSource": {
    "MulticastIp": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "flowSource": {
    "FlowArn": "",
    "FlowVpcInterfaceAttachment": ""
  },
  "networkSource": {
    "MulticastIp": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v1/bridges/:bridgeArn/sources/:sourceName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"

payload = {
    "flowSource": {
        "FlowArn": "",
        "FlowVpcInterfaceAttachment": ""
    },
    "networkSource": {
        "MulticastIp": "",
        "NetworkName": "",
        "Port": "",
        "Protocol": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName"

payload <- "{\n  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")

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  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/v1/bridges/:bridgeArn/sources/:sourceName') do |req|
  req.body = "{\n  \"flowSource\": {\n    \"FlowArn\": \"\",\n    \"FlowVpcInterfaceAttachment\": \"\"\n  },\n  \"networkSource\": {\n    \"MulticastIp\": \"\",\n    \"NetworkName\": \"\",\n    \"Port\": \"\",\n    \"Protocol\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName";

    let payload = json!({
        "flowSource": json!({
            "FlowArn": "",
            "FlowVpcInterfaceAttachment": ""
        }),
        "networkSource": json!({
            "MulticastIp": "",
            "NetworkName": "",
            "Port": "",
            "Protocol": ""
        })
    });

    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}}/v1/bridges/:bridgeArn/sources/:sourceName \
  --header 'content-type: application/json' \
  --data '{
  "flowSource": {
    "FlowArn": "",
    "FlowVpcInterfaceAttachment": ""
  },
  "networkSource": {
    "MulticastIp": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": ""
  }
}'

echo '{
  "flowSource": {
    "FlowArn": "",
    "FlowVpcInterfaceAttachment": ""
  },
  "networkSource": {
    "MulticastIp": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": ""
  }
}' |  \
  http PUT {{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "flowSource": {\n    "FlowArn": "",\n    "FlowVpcInterfaceAttachment": ""\n  },\n  "networkSource": {\n    "MulticastIp": "",\n    "NetworkName": "",\n    "Port": "",\n    "Protocol": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "flowSource": [
    "FlowArn": "",
    "FlowVpcInterfaceAttachment": ""
  ],
  "networkSource": [
    "MulticastIp": "",
    "NetworkName": "",
    "Port": "",
    "Protocol": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/bridges/:bridgeArn/sources/:sourceName")! 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 UpdateBridgeState

{{baseUrl}}/v1/bridges/:bridgeArn/state

QUERY PARAMS

bridgeArn

BODY json

{
  "desiredState": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/bridges/:bridgeArn/state");

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  \"desiredState\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v1/bridges/:bridgeArn/state" {:content-type :json
                                                                       :form-params {:desiredState ""}})

require "http/client"

url = "{{baseUrl}}/v1/bridges/:bridgeArn/state"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"desiredState\": \"\"\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}}/v1/bridges/:bridgeArn/state"),
    Content = new StringContent("{\n  \"desiredState\": \"\"\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}}/v1/bridges/:bridgeArn/state");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"desiredState\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/bridges/:bridgeArn/state"

	payload := strings.NewReader("{\n  \"desiredState\": \"\"\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/v1/bridges/:bridgeArn/state HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24

{
  "desiredState": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/bridges/:bridgeArn/state")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"desiredState\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/bridges/:bridgeArn/state"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"desiredState\": \"\"\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  \"desiredState\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/state")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v1/bridges/:bridgeArn/state")
  .header("content-type", "application/json")
  .body("{\n  \"desiredState\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  desiredState: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v1/bridges/:bridgeArn/state');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/state',
  headers: {'content-type': 'application/json'},
  data: {desiredState: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/state';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"desiredState":""}'
};

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}}/v1/bridges/:bridgeArn/state',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "desiredState": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"desiredState\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/bridges/:bridgeArn/state")
  .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/v1/bridges/:bridgeArn/state',
  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({desiredState: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/bridges/:bridgeArn/state',
  headers: {'content-type': 'application/json'},
  body: {desiredState: ''},
  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}}/v1/bridges/:bridgeArn/state');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  desiredState: ''
});

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}}/v1/bridges/:bridgeArn/state',
  headers: {'content-type': 'application/json'},
  data: {desiredState: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/bridges/:bridgeArn/state';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"desiredState":""}'
};

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 = @{ @"desiredState": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/bridges/:bridgeArn/state"]
                                                       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}}/v1/bridges/:bridgeArn/state" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"desiredState\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/bridges/:bridgeArn/state",
  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([
    'desiredState' => ''
  ]),
  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}}/v1/bridges/:bridgeArn/state', [
  'body' => '{
  "desiredState": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/bridges/:bridgeArn/state');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'desiredState' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'desiredState' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/bridges/:bridgeArn/state');
$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}}/v1/bridges/:bridgeArn/state' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "desiredState": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/bridges/:bridgeArn/state' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "desiredState": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"desiredState\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v1/bridges/:bridgeArn/state", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/bridges/:bridgeArn/state"

payload = { "desiredState": "" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/bridges/:bridgeArn/state"

payload <- "{\n  \"desiredState\": \"\"\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}}/v1/bridges/:bridgeArn/state")

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  \"desiredState\": \"\"\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/v1/bridges/:bridgeArn/state') do |req|
  req.body = "{\n  \"desiredState\": \"\"\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}}/v1/bridges/:bridgeArn/state";

    let payload = json!({"desiredState": ""});

    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}}/v1/bridges/:bridgeArn/state \
  --header 'content-type: application/json' \
  --data '{
  "desiredState": ""
}'

echo '{
  "desiredState": ""
}' |  \
  http PUT {{baseUrl}}/v1/bridges/:bridgeArn/state \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "desiredState": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/bridges/:bridgeArn/state

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["desiredState": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/bridges/:bridgeArn/state")! 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 UpdateFlow

{{baseUrl}}/v1/flows/:flowArn

QUERY PARAMS

flowArn

BODY json

{
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartHour": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn");

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  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v1/flows/:flowArn" {:content-type :json
                                                             :form-params {:sourceFailoverConfig {:FailoverMode ""
                                                                                                  :RecoveryWindow ""
                                                                                                  :SourcePriority ""
                                                                                                  :State ""}
                                                                           :maintenance {:MaintenanceDay ""
                                                                                         :MaintenanceScheduledDate ""
                                                                                         :MaintenanceStartHour ""}}})

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v1/flows/:flowArn"),
    Content = new StringContent("{\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\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}}/v1/flows/:flowArn");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn"

	payload := strings.NewReader("{\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v1/flows/:flowArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 244

{
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartHour": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/flows/:flowArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\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  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v1/flows/:flowArn")
  .header("content-type", "application/json")
  .body("{\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  sourceFailoverConfig: {
    FailoverMode: '',
    RecoveryWindow: '',
    SourcePriority: '',
    State: ''
  },
  maintenance: {
    MaintenanceDay: '',
    MaintenanceScheduledDate: '',
    MaintenanceStartHour: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v1/flows/:flowArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/flows/:flowArn',
  headers: {'content-type': 'application/json'},
  data: {
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
    maintenance: {MaintenanceDay: '', MaintenanceScheduledDate: '', MaintenanceStartHour: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/:flowArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"sourceFailoverConfig":{"FailoverMode":"","RecoveryWindow":"","SourcePriority":"","State":""},"maintenance":{"MaintenanceDay":"","MaintenanceScheduledDate":"","MaintenanceStartHour":""}}'
};

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}}/v1/flows/:flowArn',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "sourceFailoverConfig": {\n    "FailoverMode": "",\n    "RecoveryWindow": "",\n    "SourcePriority": "",\n    "State": ""\n  },\n  "maintenance": {\n    "MaintenanceDay": "",\n    "MaintenanceScheduledDate": "",\n    "MaintenanceStartHour": ""\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  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn")
  .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/v1/flows/:flowArn',
  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({
  sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
  maintenance: {MaintenanceDay: '', MaintenanceScheduledDate: '', MaintenanceStartHour: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/flows/:flowArn',
  headers: {'content-type': 'application/json'},
  body: {
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
    maintenance: {MaintenanceDay: '', MaintenanceScheduledDate: '', MaintenanceStartHour: ''}
  },
  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}}/v1/flows/:flowArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  sourceFailoverConfig: {
    FailoverMode: '',
    RecoveryWindow: '',
    SourcePriority: '',
    State: ''
  },
  maintenance: {
    MaintenanceDay: '',
    MaintenanceScheduledDate: '',
    MaintenanceStartHour: ''
  }
});

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}}/v1/flows/:flowArn',
  headers: {'content-type': 'application/json'},
  data: {
    sourceFailoverConfig: {FailoverMode: '', RecoveryWindow: '', SourcePriority: '', State: ''},
    maintenance: {MaintenanceDay: '', MaintenanceScheduledDate: '', MaintenanceStartHour: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/:flowArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"sourceFailoverConfig":{"FailoverMode":"","RecoveryWindow":"","SourcePriority":"","State":""},"maintenance":{"MaintenanceDay":"","MaintenanceScheduledDate":"","MaintenanceStartHour":""}}'
};

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 = @{ @"sourceFailoverConfig": @{ @"FailoverMode": @"", @"RecoveryWindow": @"", @"SourcePriority": @"", @"State": @"" },
                              @"maintenance": @{ @"MaintenanceDay": @"", @"MaintenanceScheduledDate": @"", @"MaintenanceStartHour": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/:flowArn"]
                                                       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}}/v1/flows/:flowArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/:flowArn",
  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([
    'sourceFailoverConfig' => [
        'FailoverMode' => '',
        'RecoveryWindow' => '',
        'SourcePriority' => '',
        'State' => ''
    ],
    'maintenance' => [
        'MaintenanceDay' => '',
        'MaintenanceScheduledDate' => '',
        'MaintenanceStartHour' => ''
    ]
  ]),
  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}}/v1/flows/:flowArn', [
  'body' => '{
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartHour": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'sourceFailoverConfig' => [
    'FailoverMode' => '',
    'RecoveryWindow' => '',
    'SourcePriority' => '',
    'State' => ''
  ],
  'maintenance' => [
    'MaintenanceDay' => '',
    'MaintenanceScheduledDate' => '',
    'MaintenanceStartHour' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'sourceFailoverConfig' => [
    'FailoverMode' => '',
    'RecoveryWindow' => '',
    'SourcePriority' => '',
    'State' => ''
  ],
  'maintenance' => [
    'MaintenanceDay' => '',
    'MaintenanceScheduledDate' => '',
    'MaintenanceStartHour' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/flows/:flowArn');
$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}}/v1/flows/:flowArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartHour": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartHour": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v1/flows/:flowArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/:flowArn"

payload = {
    "sourceFailoverConfig": {
        "FailoverMode": "",
        "RecoveryWindow": "",
        "SourcePriority": "",
        "State": ""
    },
    "maintenance": {
        "MaintenanceDay": "",
        "MaintenanceScheduledDate": "",
        "MaintenanceStartHour": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn"

payload <- "{\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn")

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  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/v1/flows/:flowArn') do |req|
  req.body = "{\n  \"sourceFailoverConfig\": {\n    \"FailoverMode\": \"\",\n    \"RecoveryWindow\": \"\",\n    \"SourcePriority\": \"\",\n    \"State\": \"\"\n  },\n  \"maintenance\": {\n    \"MaintenanceDay\": \"\",\n    \"MaintenanceScheduledDate\": \"\",\n    \"MaintenanceStartHour\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/flows/:flowArn";

    let payload = json!({
        "sourceFailoverConfig": json!({
            "FailoverMode": "",
            "RecoveryWindow": "",
            "SourcePriority": "",
            "State": ""
        }),
        "maintenance": json!({
            "MaintenanceDay": "",
            "MaintenanceScheduledDate": "",
            "MaintenanceStartHour": ""
        })
    });

    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}}/v1/flows/:flowArn \
  --header 'content-type: application/json' \
  --data '{
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartHour": ""
  }
}'

echo '{
  "sourceFailoverConfig": {
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  },
  "maintenance": {
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartHour": ""
  }
}' |  \
  http PUT {{baseUrl}}/v1/flows/:flowArn \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "sourceFailoverConfig": {\n    "FailoverMode": "",\n    "RecoveryWindow": "",\n    "SourcePriority": "",\n    "State": ""\n  },\n  "maintenance": {\n    "MaintenanceDay": "",\n    "MaintenanceScheduledDate": "",\n    "MaintenanceStartHour": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "sourceFailoverConfig": [
    "FailoverMode": "",
    "RecoveryWindow": "",
    "SourcePriority": "",
    "State": ""
  ],
  "maintenance": [
    "MaintenanceDay": "",
    "MaintenanceScheduledDate": "",
    "MaintenanceStartHour": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn")! 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 UpdateFlowEntitlement

{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn

QUERY PARAMS

entitlementArn

flowArn

BODY json

{
  "description": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "entitlementStatus": "",
  "subscribers": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn" {:content-type :json
                                                                                          :form-params {:description ""
                                                                                                        :encryption {:Algorithm ""
                                                                                                                     :ConstantInitializationVector ""
                                                                                                                     :DeviceId ""
                                                                                                                     :KeyType ""
                                                                                                                     :Region ""
                                                                                                                     :ResourceId ""
                                                                                                                     :RoleArn ""
                                                                                                                     :SecretArn ""
                                                                                                                     :Url ""}
                                                                                                        :entitlementStatus ""
                                                                                                        :subscribers []}})

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\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}}/v1/flows/:flowArn/entitlements/:entitlementArn"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\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}}/v1/flows/:flowArn/entitlements/:entitlementArn");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\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/v1/flows/:flowArn/entitlements/:entitlementArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 288

{
  "description": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "entitlementStatus": "",
  "subscribers": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  encryption: {
    Algorithm: '',
    ConstantInitializationVector: '',
    DeviceId: '',
    KeyType: '',
    Region: '',
    ResourceId: '',
    RoleArn: '',
    SecretArn: '',
    Url: ''
  },
  entitlementStatus: '',
  subscribers: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    encryption: {
      Algorithm: '',
      ConstantInitializationVector: '',
      DeviceId: '',
      KeyType: '',
      Region: '',
      ResourceId: '',
      RoleArn: '',
      SecretArn: '',
      Url: ''
    },
    entitlementStatus: '',
    subscribers: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","encryption":{"Algorithm":"","ConstantInitializationVector":"","DeviceId":"","KeyType":"","Region":"","ResourceId":"","RoleArn":"","SecretArn":"","Url":""},"entitlementStatus":"","subscribers":[]}'
};

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}}/v1/flows/:flowArn/entitlements/:entitlementArn',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "encryption": {\n    "Algorithm": "",\n    "ConstantInitializationVector": "",\n    "DeviceId": "",\n    "KeyType": "",\n    "Region": "",\n    "ResourceId": "",\n    "RoleArn": "",\n    "SecretArn": "",\n    "Url": ""\n  },\n  "entitlementStatus": "",\n  "subscribers": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn")
  .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/v1/flows/:flowArn/entitlements/:entitlementArn',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  description: '',
  encryption: {
    Algorithm: '',
    ConstantInitializationVector: '',
    DeviceId: '',
    KeyType: '',
    Region: '',
    ResourceId: '',
    RoleArn: '',
    SecretArn: '',
    Url: ''
  },
  entitlementStatus: '',
  subscribers: []
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn',
  headers: {'content-type': 'application/json'},
  body: {
    description: '',
    encryption: {
      Algorithm: '',
      ConstantInitializationVector: '',
      DeviceId: '',
      KeyType: '',
      Region: '',
      ResourceId: '',
      RoleArn: '',
      SecretArn: '',
      Url: ''
    },
    entitlementStatus: '',
    subscribers: []
  },
  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}}/v1/flows/:flowArn/entitlements/:entitlementArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  encryption: {
    Algorithm: '',
    ConstantInitializationVector: '',
    DeviceId: '',
    KeyType: '',
    Region: '',
    ResourceId: '',
    RoleArn: '',
    SecretArn: '',
    Url: ''
  },
  entitlementStatus: '',
  subscribers: []
});

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}}/v1/flows/:flowArn/entitlements/:entitlementArn',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    encryption: {
      Algorithm: '',
      ConstantInitializationVector: '',
      DeviceId: '',
      KeyType: '',
      Region: '',
      ResourceId: '',
      RoleArn: '',
      SecretArn: '',
      Url: ''
    },
    entitlementStatus: '',
    subscribers: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","encryption":{"Algorithm":"","ConstantInitializationVector":"","DeviceId":"","KeyType":"","Region":"","ResourceId":"","RoleArn":"","SecretArn":"","Url":""},"entitlementStatus":"","subscribers":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"encryption": @{ @"Algorithm": @"", @"ConstantInitializationVector": @"", @"DeviceId": @"", @"KeyType": @"", @"Region": @"", @"ResourceId": @"", @"RoleArn": @"", @"SecretArn": @"", @"Url": @"" },
                              @"entitlementStatus": @"",
                              @"subscribers": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn"]
                                                       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}}/v1/flows/:flowArn/entitlements/:entitlementArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn",
  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([
    'description' => '',
    'encryption' => [
        'Algorithm' => '',
        'ConstantInitializationVector' => '',
        'DeviceId' => '',
        'KeyType' => '',
        'Region' => '',
        'ResourceId' => '',
        'RoleArn' => '',
        'SecretArn' => '',
        'Url' => ''
    ],
    'entitlementStatus' => '',
    'subscribers' => [
        
    ]
  ]),
  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}}/v1/flows/:flowArn/entitlements/:entitlementArn', [
  'body' => '{
  "description": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "entitlementStatus": "",
  "subscribers": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'encryption' => [
    'Algorithm' => '',
    'ConstantInitializationVector' => '',
    'DeviceId' => '',
    'KeyType' => '',
    'Region' => '',
    'ResourceId' => '',
    'RoleArn' => '',
    'SecretArn' => '',
    'Url' => ''
  ],
  'entitlementStatus' => '',
  'subscribers' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'encryption' => [
    'Algorithm' => '',
    'ConstantInitializationVector' => '',
    'DeviceId' => '',
    'KeyType' => '',
    'Region' => '',
    'ResourceId' => '',
    'RoleArn' => '',
    'SecretArn' => '',
    'Url' => ''
  ],
  'entitlementStatus' => '',
  'subscribers' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn');
$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}}/v1/flows/:flowArn/entitlements/:entitlementArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "entitlementStatus": "",
  "subscribers": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "entitlementStatus": "",
  "subscribers": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v1/flows/:flowArn/entitlements/:entitlementArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn"

payload = {
    "description": "",
    "encryption": {
        "Algorithm": "",
        "ConstantInitializationVector": "",
        "DeviceId": "",
        "KeyType": "",
        "Region": "",
        "ResourceId": "",
        "RoleArn": "",
        "SecretArn": "",
        "Url": ""
    },
    "entitlementStatus": "",
    "subscribers": []
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn"

payload <- "{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\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}}/v1/flows/:flowArn/entitlements/:entitlementArn")

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  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\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/v1/flows/:flowArn/entitlements/:entitlementArn') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"entitlementStatus\": \"\",\n  \"subscribers\": []\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}}/v1/flows/:flowArn/entitlements/:entitlementArn";

    let payload = json!({
        "description": "",
        "encryption": json!({
            "Algorithm": "",
            "ConstantInitializationVector": "",
            "DeviceId": "",
            "KeyType": "",
            "Region": "",
            "ResourceId": "",
            "RoleArn": "",
            "SecretArn": "",
            "Url": ""
        }),
        "entitlementStatus": "",
        "subscribers": ()
    });

    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}}/v1/flows/:flowArn/entitlements/:entitlementArn \
  --header 'content-type: application/json' \
  --data '{
  "description": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "entitlementStatus": "",
  "subscribers": []
}'

echo '{
  "description": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "entitlementStatus": "",
  "subscribers": []
}' |  \
  http PUT {{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "encryption": {\n    "Algorithm": "",\n    "ConstantInitializationVector": "",\n    "DeviceId": "",\n    "KeyType": "",\n    "Region": "",\n    "ResourceId": "",\n    "RoleArn": "",\n    "SecretArn": "",\n    "Url": ""\n  },\n  "entitlementStatus": "",\n  "subscribers": []\n}' \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "encryption": [
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  ],
  "entitlementStatus": "",
  "subscribers": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/entitlements/:entitlementArn")! 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 UpdateFlowMediaStream

{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName

QUERY PARAMS

flowArn

mediaStreamName

BODY json

{
  "attributes": {
    "Fmtp": "",
    "Lang": ""
  },
  "clockRate": 0,
  "description": "",
  "mediaStreamType": "",
  "videoFormat": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName");

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  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName" {:content-type :json
                                                                                           :form-params {:attributes {:Fmtp ""
                                                                                                                      :Lang ""}
                                                                                                         :clockRate 0
                                                                                                         :description ""
                                                                                                         :mediaStreamType ""
                                                                                                         :videoFormat ""}})

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"),
    Content = new StringContent("{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"

	payload := strings.NewReader("{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\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/v1/flows/:flowArn/mediaStreams/:mediaStreamName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 141

{
  "attributes": {
    "Fmtp": "",
    "Lang": ""
  },
  "clockRate": 0,
  "description": "",
  "mediaStreamType": "",
  "videoFormat": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\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  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")
  .header("content-type", "application/json")
  .body("{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  attributes: {
    Fmtp: '',
    Lang: ''
  },
  clockRate: 0,
  description: '',
  mediaStreamType: '',
  videoFormat: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName',
  headers: {'content-type': 'application/json'},
  data: {
    attributes: {Fmtp: '', Lang: ''},
    clockRate: 0,
    description: '',
    mediaStreamType: '',
    videoFormat: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{"Fmtp":"","Lang":""},"clockRate":0,"description":"","mediaStreamType":"","videoFormat":""}'
};

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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "attributes": {\n    "Fmtp": "",\n    "Lang": ""\n  },\n  "clockRate": 0,\n  "description": "",\n  "mediaStreamType": "",\n  "videoFormat": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")
  .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/v1/flows/:flowArn/mediaStreams/:mediaStreamName',
  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({
  attributes: {Fmtp: '', Lang: ''},
  clockRate: 0,
  description: '',
  mediaStreamType: '',
  videoFormat: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName',
  headers: {'content-type': 'application/json'},
  body: {
    attributes: {Fmtp: '', Lang: ''},
    clockRate: 0,
    description: '',
    mediaStreamType: '',
    videoFormat: ''
  },
  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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  attributes: {
    Fmtp: '',
    Lang: ''
  },
  clockRate: 0,
  description: '',
  mediaStreamType: '',
  videoFormat: ''
});

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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName',
  headers: {'content-type': 'application/json'},
  data: {
    attributes: {Fmtp: '', Lang: ''},
    clockRate: 0,
    description: '',
    mediaStreamType: '',
    videoFormat: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"attributes":{"Fmtp":"","Lang":""},"clockRate":0,"description":"","mediaStreamType":"","videoFormat":""}'
};

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 = @{ @"attributes": @{ @"Fmtp": @"", @"Lang": @"" },
                              @"clockRate": @0,
                              @"description": @"",
                              @"mediaStreamType": @"",
                              @"videoFormat": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"]
                                                       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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName",
  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([
    'attributes' => [
        'Fmtp' => '',
        'Lang' => ''
    ],
    'clockRate' => 0,
    'description' => '',
    'mediaStreamType' => '',
    'videoFormat' => ''
  ]),
  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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName', [
  'body' => '{
  "attributes": {
    "Fmtp": "",
    "Lang": ""
  },
  "clockRate": 0,
  "description": "",
  "mediaStreamType": "",
  "videoFormat": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'attributes' => [
    'Fmtp' => '',
    'Lang' => ''
  ],
  'clockRate' => 0,
  'description' => '',
  'mediaStreamType' => '',
  'videoFormat' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'attributes' => [
    'Fmtp' => '',
    'Lang' => ''
  ],
  'clockRate' => 0,
  'description' => '',
  'mediaStreamType' => '',
  'videoFormat' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName');
$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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {
    "Fmtp": "",
    "Lang": ""
  },
  "clockRate": 0,
  "description": "",
  "mediaStreamType": "",
  "videoFormat": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "attributes": {
    "Fmtp": "",
    "Lang": ""
  },
  "clockRate": 0,
  "description": "",
  "mediaStreamType": "",
  "videoFormat": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v1/flows/:flowArn/mediaStreams/:mediaStreamName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"

payload = {
    "attributes": {
        "Fmtp": "",
        "Lang": ""
    },
    "clockRate": 0,
    "description": "",
    "mediaStreamType": "",
    "videoFormat": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName"

payload <- "{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")

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  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\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/v1/flows/:flowArn/mediaStreams/:mediaStreamName') do |req|
  req.body = "{\n  \"attributes\": {\n    \"Fmtp\": \"\",\n    \"Lang\": \"\"\n  },\n  \"clockRate\": 0,\n  \"description\": \"\",\n  \"mediaStreamType\": \"\",\n  \"videoFormat\": \"\"\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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName";

    let payload = json!({
        "attributes": json!({
            "Fmtp": "",
            "Lang": ""
        }),
        "clockRate": 0,
        "description": "",
        "mediaStreamType": "",
        "videoFormat": ""
    });

    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}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName \
  --header 'content-type: application/json' \
  --data '{
  "attributes": {
    "Fmtp": "",
    "Lang": ""
  },
  "clockRate": 0,
  "description": "",
  "mediaStreamType": "",
  "videoFormat": ""
}'

echo '{
  "attributes": {
    "Fmtp": "",
    "Lang": ""
  },
  "clockRate": 0,
  "description": "",
  "mediaStreamType": "",
  "videoFormat": ""
}' |  \
  http PUT {{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "attributes": {\n    "Fmtp": "",\n    "Lang": ""\n  },\n  "clockRate": 0,\n  "description": "",\n  "mediaStreamType": "",\n  "videoFormat": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "attributes": [
    "Fmtp": "",
    "Lang": ""
  ],
  "clockRate": 0,
  "description": "",
  "mediaStreamType": "",
  "videoFormat": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/mediaStreams/:mediaStreamName")! 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 UpdateFlowOutput

{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn

QUERY PARAMS

flowArn

outputArn

BODY json

{
  "cidrAllowList": [],
  "description": "",
  "destination": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "maxLatency": 0,
  "mediaStreamOutputConfigurations": [
    {
      "DestinationConfigurations": "",
      "EncodingName": "",
      "EncodingParameters": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "port": 0,
  "protocol": "",
  "remoteId": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "smoothingLatency": 0,
  "streamId": "",
  "vpcInterfaceAttachment": {
    "VpcInterfaceName": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn");

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  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn" {:content-type :json
                                                                                :form-params {:cidrAllowList []
                                                                                              :description ""
                                                                                              :destination ""
                                                                                              :encryption {:Algorithm ""
                                                                                                           :ConstantInitializationVector ""
                                                                                                           :DeviceId ""
                                                                                                           :KeyType ""
                                                                                                           :Region ""
                                                                                                           :ResourceId ""
                                                                                                           :RoleArn ""
                                                                                                           :SecretArn ""
                                                                                                           :Url ""}
                                                                                              :maxLatency 0
                                                                                              :mediaStreamOutputConfigurations [{:DestinationConfigurations ""
                                                                                                                                 :EncodingName ""
                                                                                                                                 :EncodingParameters ""
                                                                                                                                 :MediaStreamName ""}]
                                                                                              :minLatency 0
                                                                                              :port 0
                                                                                              :protocol ""
                                                                                              :remoteId ""
                                                                                              :senderControlPort 0
                                                                                              :senderIpAddress ""
                                                                                              :smoothingLatency 0
                                                                                              :streamId ""
                                                                                              :vpcInterfaceAttachment {:VpcInterfaceName ""}}})

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"),
    Content = new StringContent("{\n  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\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}}/v1/flows/:flowArn/outputs/:outputArn");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"

	payload := strings.NewReader("{\n  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v1/flows/:flowArn/outputs/:outputArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 708

{
  "cidrAllowList": [],
  "description": "",
  "destination": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "maxLatency": 0,
  "mediaStreamOutputConfigurations": [
    {
      "DestinationConfigurations": "",
      "EncodingName": "",
      "EncodingParameters": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "port": 0,
  "protocol": "",
  "remoteId": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "smoothingLatency": 0,
  "streamId": "",
  "vpcInterfaceAttachment": {
    "VpcInterfaceName": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\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  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")
  .header("content-type", "application/json")
  .body("{\n  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  cidrAllowList: [],
  description: '',
  destination: '',
  encryption: {
    Algorithm: '',
    ConstantInitializationVector: '',
    DeviceId: '',
    KeyType: '',
    Region: '',
    ResourceId: '',
    RoleArn: '',
    SecretArn: '',
    Url: ''
  },
  maxLatency: 0,
  mediaStreamOutputConfigurations: [
    {
      DestinationConfigurations: '',
      EncodingName: '',
      EncodingParameters: '',
      MediaStreamName: ''
    }
  ],
  minLatency: 0,
  port: 0,
  protocol: '',
  remoteId: '',
  senderControlPort: 0,
  senderIpAddress: '',
  smoothingLatency: 0,
  streamId: '',
  vpcInterfaceAttachment: {
    VpcInterfaceName: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn',
  headers: {'content-type': 'application/json'},
  data: {
    cidrAllowList: [],
    description: '',
    destination: '',
    encryption: {
      Algorithm: '',
      ConstantInitializationVector: '',
      DeviceId: '',
      KeyType: '',
      Region: '',
      ResourceId: '',
      RoleArn: '',
      SecretArn: '',
      Url: ''
    },
    maxLatency: 0,
    mediaStreamOutputConfigurations: [
      {
        DestinationConfigurations: '',
        EncodingName: '',
        EncodingParameters: '',
        MediaStreamName: ''
      }
    ],
    minLatency: 0,
    port: 0,
    protocol: '',
    remoteId: '',
    senderControlPort: 0,
    senderIpAddress: '',
    smoothingLatency: 0,
    streamId: '',
    vpcInterfaceAttachment: {VpcInterfaceName: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"cidrAllowList":[],"description":"","destination":"","encryption":{"Algorithm":"","ConstantInitializationVector":"","DeviceId":"","KeyType":"","Region":"","ResourceId":"","RoleArn":"","SecretArn":"","Url":""},"maxLatency":0,"mediaStreamOutputConfigurations":[{"DestinationConfigurations":"","EncodingName":"","EncodingParameters":"","MediaStreamName":""}],"minLatency":0,"port":0,"protocol":"","remoteId":"","senderControlPort":0,"senderIpAddress":"","smoothingLatency":0,"streamId":"","vpcInterfaceAttachment":{"VpcInterfaceName":""}}'
};

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}}/v1/flows/:flowArn/outputs/:outputArn',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cidrAllowList": [],\n  "description": "",\n  "destination": "",\n  "encryption": {\n    "Algorithm": "",\n    "ConstantInitializationVector": "",\n    "DeviceId": "",\n    "KeyType": "",\n    "Region": "",\n    "ResourceId": "",\n    "RoleArn": "",\n    "SecretArn": "",\n    "Url": ""\n  },\n  "maxLatency": 0,\n  "mediaStreamOutputConfigurations": [\n    {\n      "DestinationConfigurations": "",\n      "EncodingName": "",\n      "EncodingParameters": "",\n      "MediaStreamName": ""\n    }\n  ],\n  "minLatency": 0,\n  "port": 0,\n  "protocol": "",\n  "remoteId": "",\n  "senderControlPort": 0,\n  "senderIpAddress": "",\n  "smoothingLatency": 0,\n  "streamId": "",\n  "vpcInterfaceAttachment": {\n    "VpcInterfaceName": ""\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  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")
  .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/v1/flows/:flowArn/outputs/:outputArn',
  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({
  cidrAllowList: [],
  description: '',
  destination: '',
  encryption: {
    Algorithm: '',
    ConstantInitializationVector: '',
    DeviceId: '',
    KeyType: '',
    Region: '',
    ResourceId: '',
    RoleArn: '',
    SecretArn: '',
    Url: ''
  },
  maxLatency: 0,
  mediaStreamOutputConfigurations: [
    {
      DestinationConfigurations: '',
      EncodingName: '',
      EncodingParameters: '',
      MediaStreamName: ''
    }
  ],
  minLatency: 0,
  port: 0,
  protocol: '',
  remoteId: '',
  senderControlPort: 0,
  senderIpAddress: '',
  smoothingLatency: 0,
  streamId: '',
  vpcInterfaceAttachment: {VpcInterfaceName: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn',
  headers: {'content-type': 'application/json'},
  body: {
    cidrAllowList: [],
    description: '',
    destination: '',
    encryption: {
      Algorithm: '',
      ConstantInitializationVector: '',
      DeviceId: '',
      KeyType: '',
      Region: '',
      ResourceId: '',
      RoleArn: '',
      SecretArn: '',
      Url: ''
    },
    maxLatency: 0,
    mediaStreamOutputConfigurations: [
      {
        DestinationConfigurations: '',
        EncodingName: '',
        EncodingParameters: '',
        MediaStreamName: ''
      }
    ],
    minLatency: 0,
    port: 0,
    protocol: '',
    remoteId: '',
    senderControlPort: 0,
    senderIpAddress: '',
    smoothingLatency: 0,
    streamId: '',
    vpcInterfaceAttachment: {VpcInterfaceName: ''}
  },
  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}}/v1/flows/:flowArn/outputs/:outputArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  cidrAllowList: [],
  description: '',
  destination: '',
  encryption: {
    Algorithm: '',
    ConstantInitializationVector: '',
    DeviceId: '',
    KeyType: '',
    Region: '',
    ResourceId: '',
    RoleArn: '',
    SecretArn: '',
    Url: ''
  },
  maxLatency: 0,
  mediaStreamOutputConfigurations: [
    {
      DestinationConfigurations: '',
      EncodingName: '',
      EncodingParameters: '',
      MediaStreamName: ''
    }
  ],
  minLatency: 0,
  port: 0,
  protocol: '',
  remoteId: '',
  senderControlPort: 0,
  senderIpAddress: '',
  smoothingLatency: 0,
  streamId: '',
  vpcInterfaceAttachment: {
    VpcInterfaceName: ''
  }
});

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}}/v1/flows/:flowArn/outputs/:outputArn',
  headers: {'content-type': 'application/json'},
  data: {
    cidrAllowList: [],
    description: '',
    destination: '',
    encryption: {
      Algorithm: '',
      ConstantInitializationVector: '',
      DeviceId: '',
      KeyType: '',
      Region: '',
      ResourceId: '',
      RoleArn: '',
      SecretArn: '',
      Url: ''
    },
    maxLatency: 0,
    mediaStreamOutputConfigurations: [
      {
        DestinationConfigurations: '',
        EncodingName: '',
        EncodingParameters: '',
        MediaStreamName: ''
      }
    ],
    minLatency: 0,
    port: 0,
    protocol: '',
    remoteId: '',
    senderControlPort: 0,
    senderIpAddress: '',
    smoothingLatency: 0,
    streamId: '',
    vpcInterfaceAttachment: {VpcInterfaceName: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"cidrAllowList":[],"description":"","destination":"","encryption":{"Algorithm":"","ConstantInitializationVector":"","DeviceId":"","KeyType":"","Region":"","ResourceId":"","RoleArn":"","SecretArn":"","Url":""},"maxLatency":0,"mediaStreamOutputConfigurations":[{"DestinationConfigurations":"","EncodingName":"","EncodingParameters":"","MediaStreamName":""}],"minLatency":0,"port":0,"protocol":"","remoteId":"","senderControlPort":0,"senderIpAddress":"","smoothingLatency":0,"streamId":"","vpcInterfaceAttachment":{"VpcInterfaceName":""}}'
};

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 = @{ @"cidrAllowList": @[  ],
                              @"description": @"",
                              @"destination": @"",
                              @"encryption": @{ @"Algorithm": @"", @"ConstantInitializationVector": @"", @"DeviceId": @"", @"KeyType": @"", @"Region": @"", @"ResourceId": @"", @"RoleArn": @"", @"SecretArn": @"", @"Url": @"" },
                              @"maxLatency": @0,
                              @"mediaStreamOutputConfigurations": @[ @{ @"DestinationConfigurations": @"", @"EncodingName": @"", @"EncodingParameters": @"", @"MediaStreamName": @"" } ],
                              @"minLatency": @0,
                              @"port": @0,
                              @"protocol": @"",
                              @"remoteId": @"",
                              @"senderControlPort": @0,
                              @"senderIpAddress": @"",
                              @"smoothingLatency": @0,
                              @"streamId": @"",
                              @"vpcInterfaceAttachment": @{ @"VpcInterfaceName": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"]
                                                       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}}/v1/flows/:flowArn/outputs/:outputArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn",
  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([
    'cidrAllowList' => [
        
    ],
    'description' => '',
    'destination' => '',
    'encryption' => [
        'Algorithm' => '',
        'ConstantInitializationVector' => '',
        'DeviceId' => '',
        'KeyType' => '',
        'Region' => '',
        'ResourceId' => '',
        'RoleArn' => '',
        'SecretArn' => '',
        'Url' => ''
    ],
    'maxLatency' => 0,
    'mediaStreamOutputConfigurations' => [
        [
                'DestinationConfigurations' => '',
                'EncodingName' => '',
                'EncodingParameters' => '',
                'MediaStreamName' => ''
        ]
    ],
    'minLatency' => 0,
    'port' => 0,
    'protocol' => '',
    'remoteId' => '',
    'senderControlPort' => 0,
    'senderIpAddress' => '',
    'smoothingLatency' => 0,
    'streamId' => '',
    'vpcInterfaceAttachment' => [
        'VpcInterfaceName' => ''
    ]
  ]),
  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}}/v1/flows/:flowArn/outputs/:outputArn', [
  'body' => '{
  "cidrAllowList": [],
  "description": "",
  "destination": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "maxLatency": 0,
  "mediaStreamOutputConfigurations": [
    {
      "DestinationConfigurations": "",
      "EncodingName": "",
      "EncodingParameters": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "port": 0,
  "protocol": "",
  "remoteId": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "smoothingLatency": 0,
  "streamId": "",
  "vpcInterfaceAttachment": {
    "VpcInterfaceName": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cidrAllowList' => [
    
  ],
  'description' => '',
  'destination' => '',
  'encryption' => [
    'Algorithm' => '',
    'ConstantInitializationVector' => '',
    'DeviceId' => '',
    'KeyType' => '',
    'Region' => '',
    'ResourceId' => '',
    'RoleArn' => '',
    'SecretArn' => '',
    'Url' => ''
  ],
  'maxLatency' => 0,
  'mediaStreamOutputConfigurations' => [
    [
        'DestinationConfigurations' => '',
        'EncodingName' => '',
        'EncodingParameters' => '',
        'MediaStreamName' => ''
    ]
  ],
  'minLatency' => 0,
  'port' => 0,
  'protocol' => '',
  'remoteId' => '',
  'senderControlPort' => 0,
  'senderIpAddress' => '',
  'smoothingLatency' => 0,
  'streamId' => '',
  'vpcInterfaceAttachment' => [
    'VpcInterfaceName' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'cidrAllowList' => [
    
  ],
  'description' => '',
  'destination' => '',
  'encryption' => [
    'Algorithm' => '',
    'ConstantInitializationVector' => '',
    'DeviceId' => '',
    'KeyType' => '',
    'Region' => '',
    'ResourceId' => '',
    'RoleArn' => '',
    'SecretArn' => '',
    'Url' => ''
  ],
  'maxLatency' => 0,
  'mediaStreamOutputConfigurations' => [
    [
        'DestinationConfigurations' => '',
        'EncodingName' => '',
        'EncodingParameters' => '',
        'MediaStreamName' => ''
    ]
  ],
  'minLatency' => 0,
  'port' => 0,
  'protocol' => '',
  'remoteId' => '',
  'senderControlPort' => 0,
  'senderIpAddress' => '',
  'smoothingLatency' => 0,
  'streamId' => '',
  'vpcInterfaceAttachment' => [
    'VpcInterfaceName' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn');
$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}}/v1/flows/:flowArn/outputs/:outputArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "cidrAllowList": [],
  "description": "",
  "destination": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "maxLatency": 0,
  "mediaStreamOutputConfigurations": [
    {
      "DestinationConfigurations": "",
      "EncodingName": "",
      "EncodingParameters": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "port": 0,
  "protocol": "",
  "remoteId": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "smoothingLatency": 0,
  "streamId": "",
  "vpcInterfaceAttachment": {
    "VpcInterfaceName": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "cidrAllowList": [],
  "description": "",
  "destination": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "maxLatency": 0,
  "mediaStreamOutputConfigurations": [
    {
      "DestinationConfigurations": "",
      "EncodingName": "",
      "EncodingParameters": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "port": 0,
  "protocol": "",
  "remoteId": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "smoothingLatency": 0,
  "streamId": "",
  "vpcInterfaceAttachment": {
    "VpcInterfaceName": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v1/flows/:flowArn/outputs/:outputArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"

payload = {
    "cidrAllowList": [],
    "description": "",
    "destination": "",
    "encryption": {
        "Algorithm": "",
        "ConstantInitializationVector": "",
        "DeviceId": "",
        "KeyType": "",
        "Region": "",
        "ResourceId": "",
        "RoleArn": "",
        "SecretArn": "",
        "Url": ""
    },
    "maxLatency": 0,
    "mediaStreamOutputConfigurations": [
        {
            "DestinationConfigurations": "",
            "EncodingName": "",
            "EncodingParameters": "",
            "MediaStreamName": ""
        }
    ],
    "minLatency": 0,
    "port": 0,
    "protocol": "",
    "remoteId": "",
    "senderControlPort": 0,
    "senderIpAddress": "",
    "smoothingLatency": 0,
    "streamId": "",
    "vpcInterfaceAttachment": { "VpcInterfaceName": "" }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn"

payload <- "{\n  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")

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  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/v1/flows/:flowArn/outputs/:outputArn') do |req|
  req.body = "{\n  \"cidrAllowList\": [],\n  \"description\": \"\",\n  \"destination\": \"\",\n  \"encryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"maxLatency\": 0,\n  \"mediaStreamOutputConfigurations\": [\n    {\n      \"DestinationConfigurations\": \"\",\n      \"EncodingName\": \"\",\n      \"EncodingParameters\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"port\": 0,\n  \"protocol\": \"\",\n  \"remoteId\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"smoothingLatency\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceAttachment\": {\n    \"VpcInterfaceName\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn";

    let payload = json!({
        "cidrAllowList": (),
        "description": "",
        "destination": "",
        "encryption": json!({
            "Algorithm": "",
            "ConstantInitializationVector": "",
            "DeviceId": "",
            "KeyType": "",
            "Region": "",
            "ResourceId": "",
            "RoleArn": "",
            "SecretArn": "",
            "Url": ""
        }),
        "maxLatency": 0,
        "mediaStreamOutputConfigurations": (
            json!({
                "DestinationConfigurations": "",
                "EncodingName": "",
                "EncodingParameters": "",
                "MediaStreamName": ""
            })
        ),
        "minLatency": 0,
        "port": 0,
        "protocol": "",
        "remoteId": "",
        "senderControlPort": 0,
        "senderIpAddress": "",
        "smoothingLatency": 0,
        "streamId": "",
        "vpcInterfaceAttachment": json!({"VpcInterfaceName": ""})
    });

    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}}/v1/flows/:flowArn/outputs/:outputArn \
  --header 'content-type: application/json' \
  --data '{
  "cidrAllowList": [],
  "description": "",
  "destination": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "maxLatency": 0,
  "mediaStreamOutputConfigurations": [
    {
      "DestinationConfigurations": "",
      "EncodingName": "",
      "EncodingParameters": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "port": 0,
  "protocol": "",
  "remoteId": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "smoothingLatency": 0,
  "streamId": "",
  "vpcInterfaceAttachment": {
    "VpcInterfaceName": ""
  }
}'

echo '{
  "cidrAllowList": [],
  "description": "",
  "destination": "",
  "encryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "maxLatency": 0,
  "mediaStreamOutputConfigurations": [
    {
      "DestinationConfigurations": "",
      "EncodingName": "",
      "EncodingParameters": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "port": 0,
  "protocol": "",
  "remoteId": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "smoothingLatency": 0,
  "streamId": "",
  "vpcInterfaceAttachment": {
    "VpcInterfaceName": ""
  }
}' |  \
  http PUT {{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "cidrAllowList": [],\n  "description": "",\n  "destination": "",\n  "encryption": {\n    "Algorithm": "",\n    "ConstantInitializationVector": "",\n    "DeviceId": "",\n    "KeyType": "",\n    "Region": "",\n    "ResourceId": "",\n    "RoleArn": "",\n    "SecretArn": "",\n    "Url": ""\n  },\n  "maxLatency": 0,\n  "mediaStreamOutputConfigurations": [\n    {\n      "DestinationConfigurations": "",\n      "EncodingName": "",\n      "EncodingParameters": "",\n      "MediaStreamName": ""\n    }\n  ],\n  "minLatency": 0,\n  "port": 0,\n  "protocol": "",\n  "remoteId": "",\n  "senderControlPort": 0,\n  "senderIpAddress": "",\n  "smoothingLatency": 0,\n  "streamId": "",\n  "vpcInterfaceAttachment": {\n    "VpcInterfaceName": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "cidrAllowList": [],
  "description": "",
  "destination": "",
  "encryption": [
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  ],
  "maxLatency": 0,
  "mediaStreamOutputConfigurations": [
    [
      "DestinationConfigurations": "",
      "EncodingName": "",
      "EncodingParameters": "",
      "MediaStreamName": ""
    ]
  ],
  "minLatency": 0,
  "port": 0,
  "protocol": "",
  "remoteId": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "smoothingLatency": 0,
  "streamId": "",
  "vpcInterfaceAttachment": ["VpcInterfaceName": ""]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/outputs/:outputArn")! 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 UpdateFlowSource

{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn

QUERY PARAMS

flowArn

sourceArn

BODY json

{
  "decryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "description": "",
  "entitlementArn": "",
  "ingestPort": 0,
  "maxBitrate": 0,
  "maxLatency": 0,
  "maxSyncBuffer": 0,
  "mediaStreamSourceConfigurations": [
    {
      "EncodingName": "",
      "InputConfigurations": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "protocol": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "sourceListenerAddress": "",
  "sourceListenerPort": 0,
  "streamId": "",
  "vpcInterfaceName": "",
  "whitelistCidr": "",
  "gatewayBridgeSource": {
    "BridgeArn": "",
    "VpcInterfaceAttachment": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn");

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  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn" {:content-type :json
                                                                               :form-params {:decryption {:Algorithm ""
                                                                                                          :ConstantInitializationVector ""
                                                                                                          :DeviceId ""
                                                                                                          :KeyType ""
                                                                                                          :Region ""
                                                                                                          :ResourceId ""
                                                                                                          :RoleArn ""
                                                                                                          :SecretArn ""
                                                                                                          :Url ""}
                                                                                             :description ""
                                                                                             :entitlementArn ""
                                                                                             :ingestPort 0
                                                                                             :maxBitrate 0
                                                                                             :maxLatency 0
                                                                                             :maxSyncBuffer 0
                                                                                             :mediaStreamSourceConfigurations [{:EncodingName ""
                                                                                                                                :InputConfigurations ""
                                                                                                                                :MediaStreamName ""}]
                                                                                             :minLatency 0
                                                                                             :protocol ""
                                                                                             :senderControlPort 0
                                                                                             :senderIpAddress ""
                                                                                             :sourceListenerAddress ""
                                                                                             :sourceListenerPort 0
                                                                                             :streamId ""
                                                                                             :vpcInterfaceName ""
                                                                                             :whitelistCidr ""
                                                                                             :gatewayBridgeSource {:BridgeArn ""
                                                                                                                   :VpcInterfaceAttachment ""}}})

require "http/client"

url = "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"),
    Content = new StringContent("{\n  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\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}}/v1/flows/:flowArn/source/:sourceArn");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"

	payload := strings.NewReader("{\n  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v1/flows/:flowArn/source/:sourceArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 785

{
  "decryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "description": "",
  "entitlementArn": "",
  "ingestPort": 0,
  "maxBitrate": 0,
  "maxLatency": 0,
  "maxSyncBuffer": 0,
  "mediaStreamSourceConfigurations": [
    {
      "EncodingName": "",
      "InputConfigurations": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "protocol": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "sourceListenerAddress": "",
  "sourceListenerPort": 0,
  "streamId": "",
  "vpcInterfaceName": "",
  "whitelistCidr": "",
  "gatewayBridgeSource": {
    "BridgeArn": "",
    "VpcInterfaceAttachment": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\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  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")
  .header("content-type", "application/json")
  .body("{\n  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  decryption: {
    Algorithm: '',
    ConstantInitializationVector: '',
    DeviceId: '',
    KeyType: '',
    Region: '',
    ResourceId: '',
    RoleArn: '',
    SecretArn: '',
    Url: ''
  },
  description: '',
  entitlementArn: '',
  ingestPort: 0,
  maxBitrate: 0,
  maxLatency: 0,
  maxSyncBuffer: 0,
  mediaStreamSourceConfigurations: [
    {
      EncodingName: '',
      InputConfigurations: '',
      MediaStreamName: ''
    }
  ],
  minLatency: 0,
  protocol: '',
  senderControlPort: 0,
  senderIpAddress: '',
  sourceListenerAddress: '',
  sourceListenerPort: 0,
  streamId: '',
  vpcInterfaceName: '',
  whitelistCidr: '',
  gatewayBridgeSource: {
    BridgeArn: '',
    VpcInterfaceAttachment: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn',
  headers: {'content-type': 'application/json'},
  data: {
    decryption: {
      Algorithm: '',
      ConstantInitializationVector: '',
      DeviceId: '',
      KeyType: '',
      Region: '',
      ResourceId: '',
      RoleArn: '',
      SecretArn: '',
      Url: ''
    },
    description: '',
    entitlementArn: '',
    ingestPort: 0,
    maxBitrate: 0,
    maxLatency: 0,
    maxSyncBuffer: 0,
    mediaStreamSourceConfigurations: [{EncodingName: '', InputConfigurations: '', MediaStreamName: ''}],
    minLatency: 0,
    protocol: '',
    senderControlPort: 0,
    senderIpAddress: '',
    sourceListenerAddress: '',
    sourceListenerPort: 0,
    streamId: '',
    vpcInterfaceName: '',
    whitelistCidr: '',
    gatewayBridgeSource: {BridgeArn: '', VpcInterfaceAttachment: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"decryption":{"Algorithm":"","ConstantInitializationVector":"","DeviceId":"","KeyType":"","Region":"","ResourceId":"","RoleArn":"","SecretArn":"","Url":""},"description":"","entitlementArn":"","ingestPort":0,"maxBitrate":0,"maxLatency":0,"maxSyncBuffer":0,"mediaStreamSourceConfigurations":[{"EncodingName":"","InputConfigurations":"","MediaStreamName":""}],"minLatency":0,"protocol":"","senderControlPort":0,"senderIpAddress":"","sourceListenerAddress":"","sourceListenerPort":0,"streamId":"","vpcInterfaceName":"","whitelistCidr":"","gatewayBridgeSource":{"BridgeArn":"","VpcInterfaceAttachment":""}}'
};

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}}/v1/flows/:flowArn/source/:sourceArn',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "decryption": {\n    "Algorithm": "",\n    "ConstantInitializationVector": "",\n    "DeviceId": "",\n    "KeyType": "",\n    "Region": "",\n    "ResourceId": "",\n    "RoleArn": "",\n    "SecretArn": "",\n    "Url": ""\n  },\n  "description": "",\n  "entitlementArn": "",\n  "ingestPort": 0,\n  "maxBitrate": 0,\n  "maxLatency": 0,\n  "maxSyncBuffer": 0,\n  "mediaStreamSourceConfigurations": [\n    {\n      "EncodingName": "",\n      "InputConfigurations": "",\n      "MediaStreamName": ""\n    }\n  ],\n  "minLatency": 0,\n  "protocol": "",\n  "senderControlPort": 0,\n  "senderIpAddress": "",\n  "sourceListenerAddress": "",\n  "sourceListenerPort": 0,\n  "streamId": "",\n  "vpcInterfaceName": "",\n  "whitelistCidr": "",\n  "gatewayBridgeSource": {\n    "BridgeArn": "",\n    "VpcInterfaceAttachment": ""\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  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")
  .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/v1/flows/:flowArn/source/:sourceArn',
  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({
  decryption: {
    Algorithm: '',
    ConstantInitializationVector: '',
    DeviceId: '',
    KeyType: '',
    Region: '',
    ResourceId: '',
    RoleArn: '',
    SecretArn: '',
    Url: ''
  },
  description: '',
  entitlementArn: '',
  ingestPort: 0,
  maxBitrate: 0,
  maxLatency: 0,
  maxSyncBuffer: 0,
  mediaStreamSourceConfigurations: [{EncodingName: '', InputConfigurations: '', MediaStreamName: ''}],
  minLatency: 0,
  protocol: '',
  senderControlPort: 0,
  senderIpAddress: '',
  sourceListenerAddress: '',
  sourceListenerPort: 0,
  streamId: '',
  vpcInterfaceName: '',
  whitelistCidr: '',
  gatewayBridgeSource: {BridgeArn: '', VpcInterfaceAttachment: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn',
  headers: {'content-type': 'application/json'},
  body: {
    decryption: {
      Algorithm: '',
      ConstantInitializationVector: '',
      DeviceId: '',
      KeyType: '',
      Region: '',
      ResourceId: '',
      RoleArn: '',
      SecretArn: '',
      Url: ''
    },
    description: '',
    entitlementArn: '',
    ingestPort: 0,
    maxBitrate: 0,
    maxLatency: 0,
    maxSyncBuffer: 0,
    mediaStreamSourceConfigurations: [{EncodingName: '', InputConfigurations: '', MediaStreamName: ''}],
    minLatency: 0,
    protocol: '',
    senderControlPort: 0,
    senderIpAddress: '',
    sourceListenerAddress: '',
    sourceListenerPort: 0,
    streamId: '',
    vpcInterfaceName: '',
    whitelistCidr: '',
    gatewayBridgeSource: {BridgeArn: '', VpcInterfaceAttachment: ''}
  },
  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}}/v1/flows/:flowArn/source/:sourceArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  decryption: {
    Algorithm: '',
    ConstantInitializationVector: '',
    DeviceId: '',
    KeyType: '',
    Region: '',
    ResourceId: '',
    RoleArn: '',
    SecretArn: '',
    Url: ''
  },
  description: '',
  entitlementArn: '',
  ingestPort: 0,
  maxBitrate: 0,
  maxLatency: 0,
  maxSyncBuffer: 0,
  mediaStreamSourceConfigurations: [
    {
      EncodingName: '',
      InputConfigurations: '',
      MediaStreamName: ''
    }
  ],
  minLatency: 0,
  protocol: '',
  senderControlPort: 0,
  senderIpAddress: '',
  sourceListenerAddress: '',
  sourceListenerPort: 0,
  streamId: '',
  vpcInterfaceName: '',
  whitelistCidr: '',
  gatewayBridgeSource: {
    BridgeArn: '',
    VpcInterfaceAttachment: ''
  }
});

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}}/v1/flows/:flowArn/source/:sourceArn',
  headers: {'content-type': 'application/json'},
  data: {
    decryption: {
      Algorithm: '',
      ConstantInitializationVector: '',
      DeviceId: '',
      KeyType: '',
      Region: '',
      ResourceId: '',
      RoleArn: '',
      SecretArn: '',
      Url: ''
    },
    description: '',
    entitlementArn: '',
    ingestPort: 0,
    maxBitrate: 0,
    maxLatency: 0,
    maxSyncBuffer: 0,
    mediaStreamSourceConfigurations: [{EncodingName: '', InputConfigurations: '', MediaStreamName: ''}],
    minLatency: 0,
    protocol: '',
    senderControlPort: 0,
    senderIpAddress: '',
    sourceListenerAddress: '',
    sourceListenerPort: 0,
    streamId: '',
    vpcInterfaceName: '',
    whitelistCidr: '',
    gatewayBridgeSource: {BridgeArn: '', VpcInterfaceAttachment: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"decryption":{"Algorithm":"","ConstantInitializationVector":"","DeviceId":"","KeyType":"","Region":"","ResourceId":"","RoleArn":"","SecretArn":"","Url":""},"description":"","entitlementArn":"","ingestPort":0,"maxBitrate":0,"maxLatency":0,"maxSyncBuffer":0,"mediaStreamSourceConfigurations":[{"EncodingName":"","InputConfigurations":"","MediaStreamName":""}],"minLatency":0,"protocol":"","senderControlPort":0,"senderIpAddress":"","sourceListenerAddress":"","sourceListenerPort":0,"streamId":"","vpcInterfaceName":"","whitelistCidr":"","gatewayBridgeSource":{"BridgeArn":"","VpcInterfaceAttachment":""}}'
};

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 = @{ @"decryption": @{ @"Algorithm": @"", @"ConstantInitializationVector": @"", @"DeviceId": @"", @"KeyType": @"", @"Region": @"", @"ResourceId": @"", @"RoleArn": @"", @"SecretArn": @"", @"Url": @"" },
                              @"description": @"",
                              @"entitlementArn": @"",
                              @"ingestPort": @0,
                              @"maxBitrate": @0,
                              @"maxLatency": @0,
                              @"maxSyncBuffer": @0,
                              @"mediaStreamSourceConfigurations": @[ @{ @"EncodingName": @"", @"InputConfigurations": @"", @"MediaStreamName": @"" } ],
                              @"minLatency": @0,
                              @"protocol": @"",
                              @"senderControlPort": @0,
                              @"senderIpAddress": @"",
                              @"sourceListenerAddress": @"",
                              @"sourceListenerPort": @0,
                              @"streamId": @"",
                              @"vpcInterfaceName": @"",
                              @"whitelistCidr": @"",
                              @"gatewayBridgeSource": @{ @"BridgeArn": @"", @"VpcInterfaceAttachment": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"]
                                                       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}}/v1/flows/:flowArn/source/:sourceArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn",
  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([
    'decryption' => [
        'Algorithm' => '',
        'ConstantInitializationVector' => '',
        'DeviceId' => '',
        'KeyType' => '',
        'Region' => '',
        'ResourceId' => '',
        'RoleArn' => '',
        'SecretArn' => '',
        'Url' => ''
    ],
    'description' => '',
    'entitlementArn' => '',
    'ingestPort' => 0,
    'maxBitrate' => 0,
    'maxLatency' => 0,
    'maxSyncBuffer' => 0,
    'mediaStreamSourceConfigurations' => [
        [
                'EncodingName' => '',
                'InputConfigurations' => '',
                'MediaStreamName' => ''
        ]
    ],
    'minLatency' => 0,
    'protocol' => '',
    'senderControlPort' => 0,
    'senderIpAddress' => '',
    'sourceListenerAddress' => '',
    'sourceListenerPort' => 0,
    'streamId' => '',
    'vpcInterfaceName' => '',
    'whitelistCidr' => '',
    'gatewayBridgeSource' => [
        'BridgeArn' => '',
        'VpcInterfaceAttachment' => ''
    ]
  ]),
  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}}/v1/flows/:flowArn/source/:sourceArn', [
  'body' => '{
  "decryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "description": "",
  "entitlementArn": "",
  "ingestPort": 0,
  "maxBitrate": 0,
  "maxLatency": 0,
  "maxSyncBuffer": 0,
  "mediaStreamSourceConfigurations": [
    {
      "EncodingName": "",
      "InputConfigurations": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "protocol": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "sourceListenerAddress": "",
  "sourceListenerPort": 0,
  "streamId": "",
  "vpcInterfaceName": "",
  "whitelistCidr": "",
  "gatewayBridgeSource": {
    "BridgeArn": "",
    "VpcInterfaceAttachment": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'decryption' => [
    'Algorithm' => '',
    'ConstantInitializationVector' => '',
    'DeviceId' => '',
    'KeyType' => '',
    'Region' => '',
    'ResourceId' => '',
    'RoleArn' => '',
    'SecretArn' => '',
    'Url' => ''
  ],
  'description' => '',
  'entitlementArn' => '',
  'ingestPort' => 0,
  'maxBitrate' => 0,
  'maxLatency' => 0,
  'maxSyncBuffer' => 0,
  'mediaStreamSourceConfigurations' => [
    [
        'EncodingName' => '',
        'InputConfigurations' => '',
        'MediaStreamName' => ''
    ]
  ],
  'minLatency' => 0,
  'protocol' => '',
  'senderControlPort' => 0,
  'senderIpAddress' => '',
  'sourceListenerAddress' => '',
  'sourceListenerPort' => 0,
  'streamId' => '',
  'vpcInterfaceName' => '',
  'whitelistCidr' => '',
  'gatewayBridgeSource' => [
    'BridgeArn' => '',
    'VpcInterfaceAttachment' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'decryption' => [
    'Algorithm' => '',
    'ConstantInitializationVector' => '',
    'DeviceId' => '',
    'KeyType' => '',
    'Region' => '',
    'ResourceId' => '',
    'RoleArn' => '',
    'SecretArn' => '',
    'Url' => ''
  ],
  'description' => '',
  'entitlementArn' => '',
  'ingestPort' => 0,
  'maxBitrate' => 0,
  'maxLatency' => 0,
  'maxSyncBuffer' => 0,
  'mediaStreamSourceConfigurations' => [
    [
        'EncodingName' => '',
        'InputConfigurations' => '',
        'MediaStreamName' => ''
    ]
  ],
  'minLatency' => 0,
  'protocol' => '',
  'senderControlPort' => 0,
  'senderIpAddress' => '',
  'sourceListenerAddress' => '',
  'sourceListenerPort' => 0,
  'streamId' => '',
  'vpcInterfaceName' => '',
  'whitelistCidr' => '',
  'gatewayBridgeSource' => [
    'BridgeArn' => '',
    'VpcInterfaceAttachment' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn');
$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}}/v1/flows/:flowArn/source/:sourceArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "decryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "description": "",
  "entitlementArn": "",
  "ingestPort": 0,
  "maxBitrate": 0,
  "maxLatency": 0,
  "maxSyncBuffer": 0,
  "mediaStreamSourceConfigurations": [
    {
      "EncodingName": "",
      "InputConfigurations": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "protocol": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "sourceListenerAddress": "",
  "sourceListenerPort": 0,
  "streamId": "",
  "vpcInterfaceName": "",
  "whitelistCidr": "",
  "gatewayBridgeSource": {
    "BridgeArn": "",
    "VpcInterfaceAttachment": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "decryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "description": "",
  "entitlementArn": "",
  "ingestPort": 0,
  "maxBitrate": 0,
  "maxLatency": 0,
  "maxSyncBuffer": 0,
  "mediaStreamSourceConfigurations": [
    {
      "EncodingName": "",
      "InputConfigurations": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "protocol": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "sourceListenerAddress": "",
  "sourceListenerPort": 0,
  "streamId": "",
  "vpcInterfaceName": "",
  "whitelistCidr": "",
  "gatewayBridgeSource": {
    "BridgeArn": "",
    "VpcInterfaceAttachment": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v1/flows/:flowArn/source/:sourceArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"

payload = {
    "decryption": {
        "Algorithm": "",
        "ConstantInitializationVector": "",
        "DeviceId": "",
        "KeyType": "",
        "Region": "",
        "ResourceId": "",
        "RoleArn": "",
        "SecretArn": "",
        "Url": ""
    },
    "description": "",
    "entitlementArn": "",
    "ingestPort": 0,
    "maxBitrate": 0,
    "maxLatency": 0,
    "maxSyncBuffer": 0,
    "mediaStreamSourceConfigurations": [
        {
            "EncodingName": "",
            "InputConfigurations": "",
            "MediaStreamName": ""
        }
    ],
    "minLatency": 0,
    "protocol": "",
    "senderControlPort": 0,
    "senderIpAddress": "",
    "sourceListenerAddress": "",
    "sourceListenerPort": 0,
    "streamId": "",
    "vpcInterfaceName": "",
    "whitelistCidr": "",
    "gatewayBridgeSource": {
        "BridgeArn": "",
        "VpcInterfaceAttachment": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn"

payload <- "{\n  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")

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  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/v1/flows/:flowArn/source/:sourceArn') do |req|
  req.body = "{\n  \"decryption\": {\n    \"Algorithm\": \"\",\n    \"ConstantInitializationVector\": \"\",\n    \"DeviceId\": \"\",\n    \"KeyType\": \"\",\n    \"Region\": \"\",\n    \"ResourceId\": \"\",\n    \"RoleArn\": \"\",\n    \"SecretArn\": \"\",\n    \"Url\": \"\"\n  },\n  \"description\": \"\",\n  \"entitlementArn\": \"\",\n  \"ingestPort\": 0,\n  \"maxBitrate\": 0,\n  \"maxLatency\": 0,\n  \"maxSyncBuffer\": 0,\n  \"mediaStreamSourceConfigurations\": [\n    {\n      \"EncodingName\": \"\",\n      \"InputConfigurations\": \"\",\n      \"MediaStreamName\": \"\"\n    }\n  ],\n  \"minLatency\": 0,\n  \"protocol\": \"\",\n  \"senderControlPort\": 0,\n  \"senderIpAddress\": \"\",\n  \"sourceListenerAddress\": \"\",\n  \"sourceListenerPort\": 0,\n  \"streamId\": \"\",\n  \"vpcInterfaceName\": \"\",\n  \"whitelistCidr\": \"\",\n  \"gatewayBridgeSource\": {\n    \"BridgeArn\": \"\",\n    \"VpcInterfaceAttachment\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn";

    let payload = json!({
        "decryption": json!({
            "Algorithm": "",
            "ConstantInitializationVector": "",
            "DeviceId": "",
            "KeyType": "",
            "Region": "",
            "ResourceId": "",
            "RoleArn": "",
            "SecretArn": "",
            "Url": ""
        }),
        "description": "",
        "entitlementArn": "",
        "ingestPort": 0,
        "maxBitrate": 0,
        "maxLatency": 0,
        "maxSyncBuffer": 0,
        "mediaStreamSourceConfigurations": (
            json!({
                "EncodingName": "",
                "InputConfigurations": "",
                "MediaStreamName": ""
            })
        ),
        "minLatency": 0,
        "protocol": "",
        "senderControlPort": 0,
        "senderIpAddress": "",
        "sourceListenerAddress": "",
        "sourceListenerPort": 0,
        "streamId": "",
        "vpcInterfaceName": "",
        "whitelistCidr": "",
        "gatewayBridgeSource": json!({
            "BridgeArn": "",
            "VpcInterfaceAttachment": ""
        })
    });

    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}}/v1/flows/:flowArn/source/:sourceArn \
  --header 'content-type: application/json' \
  --data '{
  "decryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "description": "",
  "entitlementArn": "",
  "ingestPort": 0,
  "maxBitrate": 0,
  "maxLatency": 0,
  "maxSyncBuffer": 0,
  "mediaStreamSourceConfigurations": [
    {
      "EncodingName": "",
      "InputConfigurations": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "protocol": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "sourceListenerAddress": "",
  "sourceListenerPort": 0,
  "streamId": "",
  "vpcInterfaceName": "",
  "whitelistCidr": "",
  "gatewayBridgeSource": {
    "BridgeArn": "",
    "VpcInterfaceAttachment": ""
  }
}'

echo '{
  "decryption": {
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  },
  "description": "",
  "entitlementArn": "",
  "ingestPort": 0,
  "maxBitrate": 0,
  "maxLatency": 0,
  "maxSyncBuffer": 0,
  "mediaStreamSourceConfigurations": [
    {
      "EncodingName": "",
      "InputConfigurations": "",
      "MediaStreamName": ""
    }
  ],
  "minLatency": 0,
  "protocol": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "sourceListenerAddress": "",
  "sourceListenerPort": 0,
  "streamId": "",
  "vpcInterfaceName": "",
  "whitelistCidr": "",
  "gatewayBridgeSource": {
    "BridgeArn": "",
    "VpcInterfaceAttachment": ""
  }
}' |  \
  http PUT {{baseUrl}}/v1/flows/:flowArn/source/:sourceArn \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "decryption": {\n    "Algorithm": "",\n    "ConstantInitializationVector": "",\n    "DeviceId": "",\n    "KeyType": "",\n    "Region": "",\n    "ResourceId": "",\n    "RoleArn": "",\n    "SecretArn": "",\n    "Url": ""\n  },\n  "description": "",\n  "entitlementArn": "",\n  "ingestPort": 0,\n  "maxBitrate": 0,\n  "maxLatency": 0,\n  "maxSyncBuffer": 0,\n  "mediaStreamSourceConfigurations": [\n    {\n      "EncodingName": "",\n      "InputConfigurations": "",\n      "MediaStreamName": ""\n    }\n  ],\n  "minLatency": 0,\n  "protocol": "",\n  "senderControlPort": 0,\n  "senderIpAddress": "",\n  "sourceListenerAddress": "",\n  "sourceListenerPort": 0,\n  "streamId": "",\n  "vpcInterfaceName": "",\n  "whitelistCidr": "",\n  "gatewayBridgeSource": {\n    "BridgeArn": "",\n    "VpcInterfaceAttachment": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/flows/:flowArn/source/:sourceArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "decryption": [
    "Algorithm": "",
    "ConstantInitializationVector": "",
    "DeviceId": "",
    "KeyType": "",
    "Region": "",
    "ResourceId": "",
    "RoleArn": "",
    "SecretArn": "",
    "Url": ""
  ],
  "description": "",
  "entitlementArn": "",
  "ingestPort": 0,
  "maxBitrate": 0,
  "maxLatency": 0,
  "maxSyncBuffer": 0,
  "mediaStreamSourceConfigurations": [
    [
      "EncodingName": "",
      "InputConfigurations": "",
      "MediaStreamName": ""
    ]
  ],
  "minLatency": 0,
  "protocol": "",
  "senderControlPort": 0,
  "senderIpAddress": "",
  "sourceListenerAddress": "",
  "sourceListenerPort": 0,
  "streamId": "",
  "vpcInterfaceName": "",
  "whitelistCidr": "",
  "gatewayBridgeSource": [
    "BridgeArn": "",
    "VpcInterfaceAttachment": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/flows/:flowArn/source/:sourceArn")! 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 UpdateGatewayInstance

{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn

QUERY PARAMS

gatewayInstanceArn

BODY json

{
  "bridgePlacement": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn");

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  \"bridgePlacement\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn" {:content-type :json
                                                                                    :form-params {:bridgePlacement ""}})

require "http/client"

url = "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"bridgePlacement\": \"\"\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}}/v1/gateway-instances/:gatewayInstanceArn"),
    Content = new StringContent("{\n  \"bridgePlacement\": \"\"\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}}/v1/gateway-instances/:gatewayInstanceArn");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"bridgePlacement\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"

	payload := strings.NewReader("{\n  \"bridgePlacement\": \"\"\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/v1/gateway-instances/:gatewayInstanceArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 27

{
  "bridgePlacement": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"bridgePlacement\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"bridgePlacement\": \"\"\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  \"bridgePlacement\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")
  .header("content-type", "application/json")
  .body("{\n  \"bridgePlacement\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  bridgePlacement: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn',
  headers: {'content-type': 'application/json'},
  data: {bridgePlacement: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"bridgePlacement":""}'
};

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}}/v1/gateway-instances/:gatewayInstanceArn',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "bridgePlacement": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"bridgePlacement\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")
  .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/v1/gateway-instances/:gatewayInstanceArn',
  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({bridgePlacement: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn',
  headers: {'content-type': 'application/json'},
  body: {bridgePlacement: ''},
  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}}/v1/gateway-instances/:gatewayInstanceArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  bridgePlacement: ''
});

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}}/v1/gateway-instances/:gatewayInstanceArn',
  headers: {'content-type': 'application/json'},
  data: {bridgePlacement: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"bridgePlacement":""}'
};

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 = @{ @"bridgePlacement": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"]
                                                       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}}/v1/gateway-instances/:gatewayInstanceArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"bridgePlacement\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn",
  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([
    'bridgePlacement' => ''
  ]),
  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}}/v1/gateway-instances/:gatewayInstanceArn', [
  'body' => '{
  "bridgePlacement": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'bridgePlacement' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'bridgePlacement' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn');
$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}}/v1/gateway-instances/:gatewayInstanceArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "bridgePlacement": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "bridgePlacement": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"bridgePlacement\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v1/gateway-instances/:gatewayInstanceArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"

payload = { "bridgePlacement": "" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn"

payload <- "{\n  \"bridgePlacement\": \"\"\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}}/v1/gateway-instances/:gatewayInstanceArn")

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  \"bridgePlacement\": \"\"\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/v1/gateway-instances/:gatewayInstanceArn') do |req|
  req.body = "{\n  \"bridgePlacement\": \"\"\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}}/v1/gateway-instances/:gatewayInstanceArn";

    let payload = json!({"bridgePlacement": ""});

    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}}/v1/gateway-instances/:gatewayInstanceArn \
  --header 'content-type: application/json' \
  --data '{
  "bridgePlacement": ""
}'

echo '{
  "bridgePlacement": ""
}' |  \
  http PUT {{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "bridgePlacement": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["bridgePlacement": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/gateway-instances/:gatewayInstanceArn")! 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()