AWS Backup

DELETE CancelLegalHold

{{baseUrl}}/legal-holds/:legalHoldId#cancelDescription

QUERY PARAMS

cancelDescription

legalHoldId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/legal-holds/:legalHoldId#cancelDescription" {:query-params {:cancelDescription ""}})

require "http/client"

url = "{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription"

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

var client = new RestClient("{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription"

	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/legal-holds/:legalHoldId?cancelDescription= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription"))
    .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}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription")
  .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}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/legal-holds/:legalHoldId#cancelDescription',
  params: {cancelDescription: ''}
};

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

const url = '{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription';
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}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/legal-holds/:legalHoldId?cancelDescription=',
  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}}/legal-holds/:legalHoldId#cancelDescription',
  qs: {cancelDescription: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/legal-holds/:legalHoldId#cancelDescription');

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

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}}/legal-holds/:legalHoldId#cancelDescription',
  params: {cancelDescription: ''}
};

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

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

const url = '{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription';
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}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription"]
                                                       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}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription" in

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

 "{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription",
  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}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription');

echo $response->getBody();

setUrl('{{baseUrl}}/legal-holds/:legalHoldId#cancelDescription');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

setRequestUrl('{{baseUrl}}/legal-holds/:legalHoldId#cancelDescription');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'cancelDescription' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/legal-holds/:legalHoldId?cancelDescription=")

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

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

import requests

url = "{{baseUrl}}/legal-holds/:legalHoldId#cancelDescription"

querystring = {"cancelDescription":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/legal-holds/:legalHoldId#cancelDescription"

queryString <- list(cancelDescription = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription")

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/legal-holds/:legalHoldId') do |req|
  req.params['cancelDescription'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/legal-holds/:legalHoldId#cancelDescription";

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

    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}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription'

http DELETE '{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/legal-holds/:legalHoldId?cancelDescription=#cancelDescription")! 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 CreateBackupPlan

{{baseUrl}}/backup/plans/

BODY json

{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  },
  "BackupPlanTags": {},
  "CreatorRequestId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/backup/plans/" {:content-type :json
                                                         :form-params {:BackupPlan {:BackupPlanName ""
                                                                                    :Rules ""
                                                                                    :AdvancedBackupSettings ""}
                                                                       :BackupPlanTags {}
                                                                       :CreatorRequestId ""}})

require "http/client"

url = "{{baseUrl}}/backup/plans/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\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}}/backup/plans/"),
    Content = new StringContent("{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\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}}/backup/plans/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup/plans/"

	payload := strings.NewReader("{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\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/backup/plans/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 151

{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  },
  "BackupPlanTags": {},
  "CreatorRequestId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/backup/plans/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup/plans/"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\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  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/backup/plans/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/backup/plans/")
  .header("content-type", "application/json")
  .body("{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  BackupPlan: {
    BackupPlanName: '',
    Rules: '',
    AdvancedBackupSettings: ''
  },
  BackupPlanTags: {},
  CreatorRequestId: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup/plans/',
  headers: {'content-type': 'application/json'},
  data: {
    BackupPlan: {BackupPlanName: '', Rules: '', AdvancedBackupSettings: ''},
    BackupPlanTags: {},
    CreatorRequestId: ''
  }
};

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

const url = '{{baseUrl}}/backup/plans/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"BackupPlan":{"BackupPlanName":"","Rules":"","AdvancedBackupSettings":""},"BackupPlanTags":{},"CreatorRequestId":""}'
};

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}}/backup/plans/',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BackupPlan": {\n    "BackupPlanName": "",\n    "Rules": "",\n    "AdvancedBackupSettings": ""\n  },\n  "BackupPlanTags": {},\n  "CreatorRequestId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/backup/plans/")
  .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/backup/plans/',
  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({
  BackupPlan: {BackupPlanName: '', Rules: '', AdvancedBackupSettings: ''},
  BackupPlanTags: {},
  CreatorRequestId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup/plans/',
  headers: {'content-type': 'application/json'},
  body: {
    BackupPlan: {BackupPlanName: '', Rules: '', AdvancedBackupSettings: ''},
    BackupPlanTags: {},
    CreatorRequestId: ''
  },
  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}}/backup/plans/');

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

req.type('json');
req.send({
  BackupPlan: {
    BackupPlanName: '',
    Rules: '',
    AdvancedBackupSettings: ''
  },
  BackupPlanTags: {},
  CreatorRequestId: ''
});

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}}/backup/plans/',
  headers: {'content-type': 'application/json'},
  data: {
    BackupPlan: {BackupPlanName: '', Rules: '', AdvancedBackupSettings: ''},
    BackupPlanTags: {},
    CreatorRequestId: ''
  }
};

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

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

const url = '{{baseUrl}}/backup/plans/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"BackupPlan":{"BackupPlanName":"","Rules":"","AdvancedBackupSettings":""},"BackupPlanTags":{},"CreatorRequestId":""}'
};

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 = @{ @"BackupPlan": @{ @"BackupPlanName": @"", @"Rules": @"", @"AdvancedBackupSettings": @"" },
                              @"BackupPlanTags": @{  },
                              @"CreatorRequestId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backup/plans/"]
                                                       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}}/backup/plans/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\n}" in

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

 "{{baseUrl}}/backup/plans/",
  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([
    'BackupPlan' => [
        'BackupPlanName' => '',
        'Rules' => '',
        'AdvancedBackupSettings' => ''
    ],
    'BackupPlanTags' => [
        
    ],
    'CreatorRequestId' => ''
  ]),
  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}}/backup/plans/', [
  'body' => '{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  },
  "BackupPlanTags": {},
  "CreatorRequestId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BackupPlan' => [
    'BackupPlanName' => '',
    'Rules' => '',
    'AdvancedBackupSettings' => ''
  ],
  'BackupPlanTags' => [
    
  ],
  'CreatorRequestId' => ''
]));

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

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

append(json_encode([
  'BackupPlan' => [
    'BackupPlanName' => '',
    'Rules' => '',
    'AdvancedBackupSettings' => ''
  ],
  'BackupPlanTags' => [
    
  ],
  'CreatorRequestId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backup/plans/');
$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}}/backup/plans/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  },
  "BackupPlanTags": {},
  "CreatorRequestId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/plans/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  },
  "BackupPlanTags": {},
  "CreatorRequestId": ""
}'

import http.client

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

payload = "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/backup/plans/"

payload = {
    "BackupPlan": {
        "BackupPlanName": "",
        "Rules": "",
        "AdvancedBackupSettings": ""
    },
    "BackupPlanTags": {},
    "CreatorRequestId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/plans/"

payload <- "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\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}}/backup/plans/")

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  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\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/backup/plans/') do |req|
  req.body = "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  },\n  \"BackupPlanTags\": {},\n  \"CreatorRequestId\": \"\"\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}}/backup/plans/";

    let payload = json!({
        "BackupPlan": json!({
            "BackupPlanName": "",
            "Rules": "",
            "AdvancedBackupSettings": ""
        }),
        "BackupPlanTags": json!({}),
        "CreatorRequestId": ""
    });

    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}}/backup/plans/ \
  --header 'content-type: application/json' \
  --data '{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  },
  "BackupPlanTags": {},
  "CreatorRequestId": ""
}'

echo '{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  },
  "BackupPlanTags": {},
  "CreatorRequestId": ""
}' |  \
  http PUT {{baseUrl}}/backup/plans/ \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "BackupPlan": {\n    "BackupPlanName": "",\n    "Rules": "",\n    "AdvancedBackupSettings": ""\n  },\n  "BackupPlanTags": {},\n  "CreatorRequestId": ""\n}' \
  --output-document \
  - {{baseUrl}}/backup/plans/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "BackupPlan": [
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  ],
  "BackupPlanTags": [],
  "CreatorRequestId": ""
] as [String : Any]

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

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

{{baseUrl}}/backup/plans/:backupPlanId/selections/

QUERY PARAMS

backupPlanId

BODY json

{
  "BackupSelection": {
    "SelectionName": "",
    "IamRoleArn": "",
    "Resources": "",
    "ListOfTags": "",
    "NotResources": "",
    "Conditions": ""
  },
  "CreatorRequestId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/plans/:backupPlanId/selections/");

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  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/backup/plans/:backupPlanId/selections/" {:content-type :json
                                                                                  :form-params {:BackupSelection {:SelectionName ""
                                                                                                                  :IamRoleArn ""
                                                                                                                  :Resources ""
                                                                                                                  :ListOfTags ""
                                                                                                                  :NotResources ""
                                                                                                                  :Conditions ""}
                                                                                                :CreatorRequestId ""}})

require "http/client"

url = "{{baseUrl}}/backup/plans/:backupPlanId/selections/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\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}}/backup/plans/:backupPlanId/selections/"),
    Content = new StringContent("{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\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}}/backup/plans/:backupPlanId/selections/");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup/plans/:backupPlanId/selections/"

	payload := strings.NewReader("{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\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/backup/plans/:backupPlanId/selections/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 191

{
  "BackupSelection": {
    "SelectionName": "",
    "IamRoleArn": "",
    "Resources": "",
    "ListOfTags": "",
    "NotResources": "",
    "Conditions": ""
  },
  "CreatorRequestId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/backup/plans/:backupPlanId/selections/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup/plans/:backupPlanId/selections/"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\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  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId/selections/")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/backup/plans/:backupPlanId/selections/")
  .header("content-type", "application/json")
  .body("{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  BackupSelection: {
    SelectionName: '',
    IamRoleArn: '',
    Resources: '',
    ListOfTags: '',
    NotResources: '',
    Conditions: ''
  },
  CreatorRequestId: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/backup/plans/:backupPlanId/selections/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup/plans/:backupPlanId/selections/',
  headers: {'content-type': 'application/json'},
  data: {
    BackupSelection: {
      SelectionName: '',
      IamRoleArn: '',
      Resources: '',
      ListOfTags: '',
      NotResources: '',
      Conditions: ''
    },
    CreatorRequestId: ''
  }
};

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

const url = '{{baseUrl}}/backup/plans/:backupPlanId/selections/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"BackupSelection":{"SelectionName":"","IamRoleArn":"","Resources":"","ListOfTags":"","NotResources":"","Conditions":""},"CreatorRequestId":""}'
};

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}}/backup/plans/:backupPlanId/selections/',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BackupSelection": {\n    "SelectionName": "",\n    "IamRoleArn": "",\n    "Resources": "",\n    "ListOfTags": "",\n    "NotResources": "",\n    "Conditions": ""\n  },\n  "CreatorRequestId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId/selections/")
  .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/backup/plans/:backupPlanId/selections/',
  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({
  BackupSelection: {
    SelectionName: '',
    IamRoleArn: '',
    Resources: '',
    ListOfTags: '',
    NotResources: '',
    Conditions: ''
  },
  CreatorRequestId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup/plans/:backupPlanId/selections/',
  headers: {'content-type': 'application/json'},
  body: {
    BackupSelection: {
      SelectionName: '',
      IamRoleArn: '',
      Resources: '',
      ListOfTags: '',
      NotResources: '',
      Conditions: ''
    },
    CreatorRequestId: ''
  },
  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}}/backup/plans/:backupPlanId/selections/');

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

req.type('json');
req.send({
  BackupSelection: {
    SelectionName: '',
    IamRoleArn: '',
    Resources: '',
    ListOfTags: '',
    NotResources: '',
    Conditions: ''
  },
  CreatorRequestId: ''
});

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}}/backup/plans/:backupPlanId/selections/',
  headers: {'content-type': 'application/json'},
  data: {
    BackupSelection: {
      SelectionName: '',
      IamRoleArn: '',
      Resources: '',
      ListOfTags: '',
      NotResources: '',
      Conditions: ''
    },
    CreatorRequestId: ''
  }
};

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

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

const url = '{{baseUrl}}/backup/plans/:backupPlanId/selections/';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"BackupSelection":{"SelectionName":"","IamRoleArn":"","Resources":"","ListOfTags":"","NotResources":"","Conditions":""},"CreatorRequestId":""}'
};

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 = @{ @"BackupSelection": @{ @"SelectionName": @"", @"IamRoleArn": @"", @"Resources": @"", @"ListOfTags": @"", @"NotResources": @"", @"Conditions": @"" },
                              @"CreatorRequestId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backup/plans/:backupPlanId/selections/"]
                                                       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}}/backup/plans/:backupPlanId/selections/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\n}" in

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

 "{{baseUrl}}/backup/plans/:backupPlanId/selections/",
  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([
    'BackupSelection' => [
        'SelectionName' => '',
        'IamRoleArn' => '',
        'Resources' => '',
        'ListOfTags' => '',
        'NotResources' => '',
        'Conditions' => ''
    ],
    'CreatorRequestId' => ''
  ]),
  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}}/backup/plans/:backupPlanId/selections/', [
  'body' => '{
  "BackupSelection": {
    "SelectionName": "",
    "IamRoleArn": "",
    "Resources": "",
    "ListOfTags": "",
    "NotResources": "",
    "Conditions": ""
  },
  "CreatorRequestId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/backup/plans/:backupPlanId/selections/');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BackupSelection' => [
    'SelectionName' => '',
    'IamRoleArn' => '',
    'Resources' => '',
    'ListOfTags' => '',
    'NotResources' => '',
    'Conditions' => ''
  ],
  'CreatorRequestId' => ''
]));

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

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

append(json_encode([
  'BackupSelection' => [
    'SelectionName' => '',
    'IamRoleArn' => '',
    'Resources' => '',
    'ListOfTags' => '',
    'NotResources' => '',
    'Conditions' => ''
  ],
  'CreatorRequestId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backup/plans/:backupPlanId/selections/');
$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}}/backup/plans/:backupPlanId/selections/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "BackupSelection": {
    "SelectionName": "",
    "IamRoleArn": "",
    "Resources": "",
    "ListOfTags": "",
    "NotResources": "",
    "Conditions": ""
  },
  "CreatorRequestId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/plans/:backupPlanId/selections/' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "BackupSelection": {
    "SelectionName": "",
    "IamRoleArn": "",
    "Resources": "",
    "ListOfTags": "",
    "NotResources": "",
    "Conditions": ""
  },
  "CreatorRequestId": ""
}'

import http.client

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

payload = "{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/backup/plans/:backupPlanId/selections/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/backup/plans/:backupPlanId/selections/"

payload = {
    "BackupSelection": {
        "SelectionName": "",
        "IamRoleArn": "",
        "Resources": "",
        "ListOfTags": "",
        "NotResources": "",
        "Conditions": ""
    },
    "CreatorRequestId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/plans/:backupPlanId/selections/"

payload <- "{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\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}}/backup/plans/:backupPlanId/selections/")

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  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\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/backup/plans/:backupPlanId/selections/') do |req|
  req.body = "{\n  \"BackupSelection\": {\n    \"SelectionName\": \"\",\n    \"IamRoleArn\": \"\",\n    \"Resources\": \"\",\n    \"ListOfTags\": \"\",\n    \"NotResources\": \"\",\n    \"Conditions\": \"\"\n  },\n  \"CreatorRequestId\": \"\"\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}}/backup/plans/:backupPlanId/selections/";

    let payload = json!({
        "BackupSelection": json!({
            "SelectionName": "",
            "IamRoleArn": "",
            "Resources": "",
            "ListOfTags": "",
            "NotResources": "",
            "Conditions": ""
        }),
        "CreatorRequestId": ""
    });

    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}}/backup/plans/:backupPlanId/selections/ \
  --header 'content-type: application/json' \
  --data '{
  "BackupSelection": {
    "SelectionName": "",
    "IamRoleArn": "",
    "Resources": "",
    "ListOfTags": "",
    "NotResources": "",
    "Conditions": ""
  },
  "CreatorRequestId": ""
}'

echo '{
  "BackupSelection": {
    "SelectionName": "",
    "IamRoleArn": "",
    "Resources": "",
    "ListOfTags": "",
    "NotResources": "",
    "Conditions": ""
  },
  "CreatorRequestId": ""
}' |  \
  http PUT {{baseUrl}}/backup/plans/:backupPlanId/selections/ \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "BackupSelection": {\n    "SelectionName": "",\n    "IamRoleArn": "",\n    "Resources": "",\n    "ListOfTags": "",\n    "NotResources": "",\n    "Conditions": ""\n  },\n  "CreatorRequestId": ""\n}' \
  --output-document \
  - {{baseUrl}}/backup/plans/:backupPlanId/selections/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "BackupSelection": [
    "SelectionName": "",
    "IamRoleArn": "",
    "Resources": "",
    "ListOfTags": "",
    "NotResources": "",
    "Conditions": ""
  ],
  "CreatorRequestId": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup/plans/:backupPlanId/selections/")! 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 CreateBackupVault

{{baseUrl}}/backup-vaults/:backupVaultName

QUERY PARAMS

backupVaultName

BODY json

{
  "BackupVaultTags": {},
  "EncryptionKeyArn": "",
  "CreatorRequestId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName");

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  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/backup-vaults/:backupVaultName" {:content-type :json
                                                                          :form-params {:BackupVaultTags {}
                                                                                        :EncryptionKeyArn ""
                                                                                        :CreatorRequestId ""}})

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\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}}/backup-vaults/:backupVaultName"),
    Content = new StringContent("{\n  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\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}}/backup-vaults/:backupVaultName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName"

	payload := strings.NewReader("{\n  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\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/backup-vaults/:backupVaultName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 79

{
  "BackupVaultTags": {},
  "EncryptionKeyArn": "",
  "CreatorRequestId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/backup-vaults/:backupVaultName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\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  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/backup-vaults/:backupVaultName")
  .header("content-type", "application/json")
  .body("{\n  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  BackupVaultTags: {},
  EncryptionKeyArn: '',
  CreatorRequestId: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName',
  headers: {'content-type': 'application/json'},
  data: {BackupVaultTags: {}, EncryptionKeyArn: '', CreatorRequestId: ''}
};

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"BackupVaultTags":{},"EncryptionKeyArn":"","CreatorRequestId":""}'
};

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}}/backup-vaults/:backupVaultName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BackupVaultTags": {},\n  "EncryptionKeyArn": "",\n  "CreatorRequestId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName")
  .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/backup-vaults/:backupVaultName',
  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({BackupVaultTags: {}, EncryptionKeyArn: '', CreatorRequestId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName',
  headers: {'content-type': 'application/json'},
  body: {BackupVaultTags: {}, EncryptionKeyArn: '', CreatorRequestId: ''},
  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}}/backup-vaults/:backupVaultName');

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

req.type('json');
req.send({
  BackupVaultTags: {},
  EncryptionKeyArn: '',
  CreatorRequestId: ''
});

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}}/backup-vaults/:backupVaultName',
  headers: {'content-type': 'application/json'},
  data: {BackupVaultTags: {}, EncryptionKeyArn: '', CreatorRequestId: ''}
};

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

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"BackupVaultTags":{},"EncryptionKeyArn":"","CreatorRequestId":""}'
};

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 = @{ @"BackupVaultTags": @{  },
                              @"EncryptionKeyArn": @"",
                              @"CreatorRequestId": @"" };

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

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

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

 "{{baseUrl}}/backup-vaults/:backupVaultName",
  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([
    'BackupVaultTags' => [
        
    ],
    'EncryptionKeyArn' => '',
    'CreatorRequestId' => ''
  ]),
  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}}/backup-vaults/:backupVaultName', [
  'body' => '{
  "BackupVaultTags": {},
  "EncryptionKeyArn": "",
  "CreatorRequestId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BackupVaultTags' => [
    
  ],
  'EncryptionKeyArn' => '',
  'CreatorRequestId' => ''
]));

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

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

append(json_encode([
  'BackupVaultTags' => [
    
  ],
  'EncryptionKeyArn' => '',
  'CreatorRequestId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName');
$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}}/backup-vaults/:backupVaultName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "BackupVaultTags": {},
  "EncryptionKeyArn": "",
  "CreatorRequestId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "BackupVaultTags": {},
  "EncryptionKeyArn": "",
  "CreatorRequestId": ""
}'

import http.client

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

payload = "{\n  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/backup-vaults/:backupVaultName", payload, headers)

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

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

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName"

payload = {
    "BackupVaultTags": {},
    "EncryptionKeyArn": "",
    "CreatorRequestId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName"

payload <- "{\n  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\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}}/backup-vaults/:backupVaultName")

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  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\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/backup-vaults/:backupVaultName') do |req|
  req.body = "{\n  \"BackupVaultTags\": {},\n  \"EncryptionKeyArn\": \"\",\n  \"CreatorRequestId\": \"\"\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}}/backup-vaults/:backupVaultName";

    let payload = json!({
        "BackupVaultTags": json!({}),
        "EncryptionKeyArn": "",
        "CreatorRequestId": ""
    });

    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}}/backup-vaults/:backupVaultName \
  --header 'content-type: application/json' \
  --data '{
  "BackupVaultTags": {},
  "EncryptionKeyArn": "",
  "CreatorRequestId": ""
}'

echo '{
  "BackupVaultTags": {},
  "EncryptionKeyArn": "",
  "CreatorRequestId": ""
}' |  \
  http PUT {{baseUrl}}/backup-vaults/:backupVaultName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "BackupVaultTags": {},\n  "EncryptionKeyArn": "",\n  "CreatorRequestId": ""\n}' \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName

import Foundation

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

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

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

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

dataTask.resume()

POST CreateFramework

{{baseUrl}}/audit/frameworks

BODY json

{
  "FrameworkName": "",
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": "",
  "FrameworkTags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/audit/frameworks" {:content-type :json
                                                             :form-params {:FrameworkName ""
                                                                           :FrameworkDescription ""
                                                                           :FrameworkControls [{:ControlName ""
                                                                                                :ControlInputParameters ""
                                                                                                :ControlScope ""}]
                                                                           :IdempotencyToken ""
                                                                           :FrameworkTags {}}})

require "http/client"

url = "{{baseUrl}}/audit/frameworks"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\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}}/audit/frameworks"),
    Content = new StringContent("{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\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}}/audit/frameworks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/audit/frameworks"

	payload := strings.NewReader("{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\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/audit/frameworks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 232

{
  "FrameworkName": "",
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": "",
  "FrameworkTags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/audit/frameworks")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/frameworks"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\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  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/audit/frameworks")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/audit/frameworks")
  .header("content-type", "application/json")
  .body("{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\n}")
  .asString();

const data = JSON.stringify({
  FrameworkName: '',
  FrameworkDescription: '',
  FrameworkControls: [
    {
      ControlName: '',
      ControlInputParameters: '',
      ControlScope: ''
    }
  ],
  IdempotencyToken: '',
  FrameworkTags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/frameworks',
  headers: {'content-type': 'application/json'},
  data: {
    FrameworkName: '',
    FrameworkDescription: '',
    FrameworkControls: [{ControlName: '', ControlInputParameters: '', ControlScope: ''}],
    IdempotencyToken: '',
    FrameworkTags: {}
  }
};

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

const url = '{{baseUrl}}/audit/frameworks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FrameworkName":"","FrameworkDescription":"","FrameworkControls":[{"ControlName":"","ControlInputParameters":"","ControlScope":""}],"IdempotencyToken":"","FrameworkTags":{}}'
};

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}}/audit/frameworks',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FrameworkName": "",\n  "FrameworkDescription": "",\n  "FrameworkControls": [\n    {\n      "ControlName": "",\n      "ControlInputParameters": "",\n      "ControlScope": ""\n    }\n  ],\n  "IdempotencyToken": "",\n  "FrameworkTags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/audit/frameworks")
  .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/audit/frameworks',
  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({
  FrameworkName: '',
  FrameworkDescription: '',
  FrameworkControls: [{ControlName: '', ControlInputParameters: '', ControlScope: ''}],
  IdempotencyToken: '',
  FrameworkTags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/frameworks',
  headers: {'content-type': 'application/json'},
  body: {
    FrameworkName: '',
    FrameworkDescription: '',
    FrameworkControls: [{ControlName: '', ControlInputParameters: '', ControlScope: ''}],
    IdempotencyToken: '',
    FrameworkTags: {}
  },
  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}}/audit/frameworks');

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

req.type('json');
req.send({
  FrameworkName: '',
  FrameworkDescription: '',
  FrameworkControls: [
    {
      ControlName: '',
      ControlInputParameters: '',
      ControlScope: ''
    }
  ],
  IdempotencyToken: '',
  FrameworkTags: {}
});

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}}/audit/frameworks',
  headers: {'content-type': 'application/json'},
  data: {
    FrameworkName: '',
    FrameworkDescription: '',
    FrameworkControls: [{ControlName: '', ControlInputParameters: '', ControlScope: ''}],
    IdempotencyToken: '',
    FrameworkTags: {}
  }
};

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

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

const url = '{{baseUrl}}/audit/frameworks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FrameworkName":"","FrameworkDescription":"","FrameworkControls":[{"ControlName":"","ControlInputParameters":"","ControlScope":""}],"IdempotencyToken":"","FrameworkTags":{}}'
};

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 = @{ @"FrameworkName": @"",
                              @"FrameworkDescription": @"",
                              @"FrameworkControls": @[ @{ @"ControlName": @"", @"ControlInputParameters": @"", @"ControlScope": @"" } ],
                              @"IdempotencyToken": @"",
                              @"FrameworkTags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/audit/frameworks"]
                                                       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}}/audit/frameworks" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\n}" in

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

 "{{baseUrl}}/audit/frameworks",
  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([
    'FrameworkName' => '',
    'FrameworkDescription' => '',
    'FrameworkControls' => [
        [
                'ControlName' => '',
                'ControlInputParameters' => '',
                'ControlScope' => ''
        ]
    ],
    'IdempotencyToken' => '',
    'FrameworkTags' => [
        
    ]
  ]),
  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}}/audit/frameworks', [
  'body' => '{
  "FrameworkName": "",
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": "",
  "FrameworkTags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FrameworkName' => '',
  'FrameworkDescription' => '',
  'FrameworkControls' => [
    [
        'ControlName' => '',
        'ControlInputParameters' => '',
        'ControlScope' => ''
    ]
  ],
  'IdempotencyToken' => '',
  'FrameworkTags' => [
    
  ]
]));

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

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

append(json_encode([
  'FrameworkName' => '',
  'FrameworkDescription' => '',
  'FrameworkControls' => [
    [
        'ControlName' => '',
        'ControlInputParameters' => '',
        'ControlScope' => ''
    ]
  ],
  'IdempotencyToken' => '',
  'FrameworkTags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/audit/frameworks');
$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}}/audit/frameworks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FrameworkName": "",
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": "",
  "FrameworkTags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/frameworks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FrameworkName": "",
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": "",
  "FrameworkTags": {}
}'

import http.client

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

payload = "{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/audit/frameworks"

payload = {
    "FrameworkName": "",
    "FrameworkDescription": "",
    "FrameworkControls": [
        {
            "ControlName": "",
            "ControlInputParameters": "",
            "ControlScope": ""
        }
    ],
    "IdempotencyToken": "",
    "FrameworkTags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/frameworks"

payload <- "{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\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}}/audit/frameworks")

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  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\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/audit/frameworks') do |req|
  req.body = "{\n  \"FrameworkName\": \"\",\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\",\n  \"FrameworkTags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "FrameworkName": "",
        "FrameworkDescription": "",
        "FrameworkControls": (
            json!({
                "ControlName": "",
                "ControlInputParameters": "",
                "ControlScope": ""
            })
        ),
        "IdempotencyToken": "",
        "FrameworkTags": 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}}/audit/frameworks \
  --header 'content-type: application/json' \
  --data '{
  "FrameworkName": "",
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": "",
  "FrameworkTags": {}
}'

echo '{
  "FrameworkName": "",
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": "",
  "FrameworkTags": {}
}' |  \
  http POST {{baseUrl}}/audit/frameworks \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "FrameworkName": "",\n  "FrameworkDescription": "",\n  "FrameworkControls": [\n    {\n      "ControlName": "",\n      "ControlInputParameters": "",\n      "ControlScope": ""\n    }\n  ],\n  "IdempotencyToken": "",\n  "FrameworkTags": {}\n}' \
  --output-document \
  - {{baseUrl}}/audit/frameworks

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "FrameworkName": "",
  "FrameworkDescription": "",
  "FrameworkControls": [
    [
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    ]
  ],
  "IdempotencyToken": "",
  "FrameworkTags": []
] as [String : Any]

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

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

{{baseUrl}}/legal-holds/

BODY json

{
  "Title": "",
  "Description": "",
  "IdempotencyToken": "",
  "RecoveryPointSelection": {
    "VaultNames": "",
    "ResourceIdentifiers": "",
    "DateRange": {
      "FromDate": "",
      "ToDate": ""
    }
  },
  "Tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/legal-holds/");

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  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/legal-holds/" {:content-type :json
                                                         :form-params {:Title ""
                                                                       :Description ""
                                                                       :IdempotencyToken ""
                                                                       :RecoveryPointSelection {:VaultNames ""
                                                                                                :ResourceIdentifiers ""
                                                                                                :DateRange {:FromDate ""
                                                                                                            :ToDate ""}}
                                                                       :Tags {}}})

require "http/client"

url = "{{baseUrl}}/legal-holds/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/legal-holds/"),
    Content = new StringContent("{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/legal-holds/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/legal-holds/"

	payload := strings.NewReader("{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}")

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

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

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

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

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

}

POST /baseUrl/legal-holds/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 232

{
  "Title": "",
  "Description": "",
  "IdempotencyToken": "",
  "RecoveryPointSelection": {
    "VaultNames": "",
    "ResourceIdentifiers": "",
    "DateRange": {
      "FromDate": "",
      "ToDate": ""
    }
  },
  "Tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/legal-holds/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/legal-holds/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/legal-holds/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/legal-holds/")
  .header("content-type", "application/json")
  .body("{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  Title: '',
  Description: '',
  IdempotencyToken: '',
  RecoveryPointSelection: {
    VaultNames: '',
    ResourceIdentifiers: '',
    DateRange: {
      FromDate: '',
      ToDate: ''
    }
  },
  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}}/legal-holds/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/legal-holds/',
  headers: {'content-type': 'application/json'},
  data: {
    Title: '',
    Description: '',
    IdempotencyToken: '',
    RecoveryPointSelection: {VaultNames: '', ResourceIdentifiers: '', DateRange: {FromDate: '', ToDate: ''}},
    Tags: {}
  }
};

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

const url = '{{baseUrl}}/legal-holds/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Title":"","Description":"","IdempotencyToken":"","RecoveryPointSelection":{"VaultNames":"","ResourceIdentifiers":"","DateRange":{"FromDate":"","ToDate":""}},"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}}/legal-holds/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Title": "",\n  "Description": "",\n  "IdempotencyToken": "",\n  "RecoveryPointSelection": {\n    "VaultNames": "",\n    "ResourceIdentifiers": "",\n    "DateRange": {\n      "FromDate": "",\n      "ToDate": ""\n    }\n  },\n  "Tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/legal-holds/")
  .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/legal-holds/',
  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({
  Title: '',
  Description: '',
  IdempotencyToken: '',
  RecoveryPointSelection: {VaultNames: '', ResourceIdentifiers: '', DateRange: {FromDate: '', ToDate: ''}},
  Tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/legal-holds/',
  headers: {'content-type': 'application/json'},
  body: {
    Title: '',
    Description: '',
    IdempotencyToken: '',
    RecoveryPointSelection: {VaultNames: '', ResourceIdentifiers: '', DateRange: {FromDate: '', ToDate: ''}},
    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}}/legal-holds/');

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

req.type('json');
req.send({
  Title: '',
  Description: '',
  IdempotencyToken: '',
  RecoveryPointSelection: {
    VaultNames: '',
    ResourceIdentifiers: '',
    DateRange: {
      FromDate: '',
      ToDate: ''
    }
  },
  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}}/legal-holds/',
  headers: {'content-type': 'application/json'},
  data: {
    Title: '',
    Description: '',
    IdempotencyToken: '',
    RecoveryPointSelection: {VaultNames: '', ResourceIdentifiers: '', DateRange: {FromDate: '', ToDate: ''}},
    Tags: {}
  }
};

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

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

const url = '{{baseUrl}}/legal-holds/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Title":"","Description":"","IdempotencyToken":"","RecoveryPointSelection":{"VaultNames":"","ResourceIdentifiers":"","DateRange":{"FromDate":"","ToDate":""}},"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 = @{ @"Title": @"",
                              @"Description": @"",
                              @"IdempotencyToken": @"",
                              @"RecoveryPointSelection": @{ @"VaultNames": @"", @"ResourceIdentifiers": @"", @"DateRange": @{ @"FromDate": @"", @"ToDate": @"" } },
                              @"Tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/legal-holds/"]
                                                       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}}/legal-holds/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}" in

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

 "{{baseUrl}}/legal-holds/",
  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([
    'Title' => '',
    'Description' => '',
    'IdempotencyToken' => '',
    'RecoveryPointSelection' => [
        'VaultNames' => '',
        'ResourceIdentifiers' => '',
        'DateRange' => [
                'FromDate' => '',
                'ToDate' => ''
        ]
    ],
    '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}}/legal-holds/', [
  'body' => '{
  "Title": "",
  "Description": "",
  "IdempotencyToken": "",
  "RecoveryPointSelection": {
    "VaultNames": "",
    "ResourceIdentifiers": "",
    "DateRange": {
      "FromDate": "",
      "ToDate": ""
    }
  },
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Title' => '',
  'Description' => '',
  'IdempotencyToken' => '',
  'RecoveryPointSelection' => [
    'VaultNames' => '',
    'ResourceIdentifiers' => '',
    'DateRange' => [
        'FromDate' => '',
        'ToDate' => ''
    ]
  ],
  'Tags' => [
    
  ]
]));

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

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

append(json_encode([
  'Title' => '',
  'Description' => '',
  'IdempotencyToken' => '',
  'RecoveryPointSelection' => [
    'VaultNames' => '',
    'ResourceIdentifiers' => '',
    'DateRange' => [
        'FromDate' => '',
        'ToDate' => ''
    ]
  ],
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/legal-holds/');
$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}}/legal-holds/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Title": "",
  "Description": "",
  "IdempotencyToken": "",
  "RecoveryPointSelection": {
    "VaultNames": "",
    "ResourceIdentifiers": "",
    "DateRange": {
      "FromDate": "",
      "ToDate": ""
    }
  },
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/legal-holds/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Title": "",
  "Description": "",
  "IdempotencyToken": "",
  "RecoveryPointSelection": {
    "VaultNames": "",
    "ResourceIdentifiers": "",
    "DateRange": {
      "FromDate": "",
      "ToDate": ""
    }
  },
  "Tags": {}
}'

import http.client

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

payload = "{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}"

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

conn.request("POST", "/baseUrl/legal-holds/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/legal-holds/"

payload = {
    "Title": "",
    "Description": "",
    "IdempotencyToken": "",
    "RecoveryPointSelection": {
        "VaultNames": "",
        "ResourceIdentifiers": "",
        "DateRange": {
            "FromDate": "",
            "ToDate": ""
        }
    },
    "Tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/legal-holds/"

payload <- "{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/legal-holds/")

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  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/legal-holds/') do |req|
  req.body = "{\n  \"Title\": \"\",\n  \"Description\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"RecoveryPointSelection\": {\n    \"VaultNames\": \"\",\n    \"ResourceIdentifiers\": \"\",\n    \"DateRange\": {\n      \"FromDate\": \"\",\n      \"ToDate\": \"\"\n    }\n  },\n  \"Tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Title": "",
        "Description": "",
        "IdempotencyToken": "",
        "RecoveryPointSelection": json!({
            "VaultNames": "",
            "ResourceIdentifiers": "",
            "DateRange": json!({
                "FromDate": "",
                "ToDate": ""
            })
        }),
        "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}}/legal-holds/ \
  --header 'content-type: application/json' \
  --data '{
  "Title": "",
  "Description": "",
  "IdempotencyToken": "",
  "RecoveryPointSelection": {
    "VaultNames": "",
    "ResourceIdentifiers": "",
    "DateRange": {
      "FromDate": "",
      "ToDate": ""
    }
  },
  "Tags": {}
}'

echo '{
  "Title": "",
  "Description": "",
  "IdempotencyToken": "",
  "RecoveryPointSelection": {
    "VaultNames": "",
    "ResourceIdentifiers": "",
    "DateRange": {
      "FromDate": "",
      "ToDate": ""
    }
  },
  "Tags": {}
}' |  \
  http POST {{baseUrl}}/legal-holds/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Title": "",\n  "Description": "",\n  "IdempotencyToken": "",\n  "RecoveryPointSelection": {\n    "VaultNames": "",\n    "ResourceIdentifiers": "",\n    "DateRange": {\n      "FromDate": "",\n      "ToDate": ""\n    }\n  },\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/legal-holds/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Title": "",
  "Description": "",
  "IdempotencyToken": "",
  "RecoveryPointSelection": [
    "VaultNames": "",
    "ResourceIdentifiers": "",
    "DateRange": [
      "FromDate": "",
      "ToDate": ""
    ]
  ],
  "Tags": []
] as [String : Any]

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

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

{{baseUrl}}/audit/report-plans

BODY json

{
  "ReportPlanName": "",
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "ReportPlanTags": {},
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/report-plans");

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  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/audit/report-plans" {:content-type :json
                                                               :form-params {:ReportPlanName ""
                                                                             :ReportPlanDescription ""
                                                                             :ReportDeliveryChannel {:S3BucketName ""
                                                                                                     :S3KeyPrefix ""
                                                                                                     :Formats ""}
                                                                             :ReportSetting {:ReportTemplate ""
                                                                                             :FrameworkArns ""
                                                                                             :NumberOfFrameworks ""
                                                                                             :Accounts ""
                                                                                             :OrganizationUnits ""
                                                                                             :Regions ""}
                                                                             :ReportPlanTags {}
                                                                             :IdempotencyToken ""}})

require "http/client"

url = "{{baseUrl}}/audit/report-plans"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\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}}/audit/report-plans"),
    Content = new StringContent("{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\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}}/audit/report-plans");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/audit/report-plans"

	payload := strings.NewReader("{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\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/audit/report-plans HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 380

{
  "ReportPlanName": "",
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "ReportPlanTags": {},
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/audit/report-plans")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/report-plans"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\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  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/audit/report-plans")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/audit/report-plans")
  .header("content-type", "application/json")
  .body("{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ReportPlanName: '',
  ReportPlanDescription: '',
  ReportDeliveryChannel: {
    S3BucketName: '',
    S3KeyPrefix: '',
    Formats: ''
  },
  ReportSetting: {
    ReportTemplate: '',
    FrameworkArns: '',
    NumberOfFrameworks: '',
    Accounts: '',
    OrganizationUnits: '',
    Regions: ''
  },
  ReportPlanTags: {},
  IdempotencyToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/report-plans',
  headers: {'content-type': 'application/json'},
  data: {
    ReportPlanName: '',
    ReportPlanDescription: '',
    ReportDeliveryChannel: {S3BucketName: '', S3KeyPrefix: '', Formats: ''},
    ReportSetting: {
      ReportTemplate: '',
      FrameworkArns: '',
      NumberOfFrameworks: '',
      Accounts: '',
      OrganizationUnits: '',
      Regions: ''
    },
    ReportPlanTags: {},
    IdempotencyToken: ''
  }
};

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

const url = '{{baseUrl}}/audit/report-plans';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ReportPlanName":"","ReportPlanDescription":"","ReportDeliveryChannel":{"S3BucketName":"","S3KeyPrefix":"","Formats":""},"ReportSetting":{"ReportTemplate":"","FrameworkArns":"","NumberOfFrameworks":"","Accounts":"","OrganizationUnits":"","Regions":""},"ReportPlanTags":{},"IdempotencyToken":""}'
};

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}}/audit/report-plans',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ReportPlanName": "",\n  "ReportPlanDescription": "",\n  "ReportDeliveryChannel": {\n    "S3BucketName": "",\n    "S3KeyPrefix": "",\n    "Formats": ""\n  },\n  "ReportSetting": {\n    "ReportTemplate": "",\n    "FrameworkArns": "",\n    "NumberOfFrameworks": "",\n    "Accounts": "",\n    "OrganizationUnits": "",\n    "Regions": ""\n  },\n  "ReportPlanTags": {},\n  "IdempotencyToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/audit/report-plans")
  .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/audit/report-plans',
  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({
  ReportPlanName: '',
  ReportPlanDescription: '',
  ReportDeliveryChannel: {S3BucketName: '', S3KeyPrefix: '', Formats: ''},
  ReportSetting: {
    ReportTemplate: '',
    FrameworkArns: '',
    NumberOfFrameworks: '',
    Accounts: '',
    OrganizationUnits: '',
    Regions: ''
  },
  ReportPlanTags: {},
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/report-plans',
  headers: {'content-type': 'application/json'},
  body: {
    ReportPlanName: '',
    ReportPlanDescription: '',
    ReportDeliveryChannel: {S3BucketName: '', S3KeyPrefix: '', Formats: ''},
    ReportSetting: {
      ReportTemplate: '',
      FrameworkArns: '',
      NumberOfFrameworks: '',
      Accounts: '',
      OrganizationUnits: '',
      Regions: ''
    },
    ReportPlanTags: {},
    IdempotencyToken: ''
  },
  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}}/audit/report-plans');

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

req.type('json');
req.send({
  ReportPlanName: '',
  ReportPlanDescription: '',
  ReportDeliveryChannel: {
    S3BucketName: '',
    S3KeyPrefix: '',
    Formats: ''
  },
  ReportSetting: {
    ReportTemplate: '',
    FrameworkArns: '',
    NumberOfFrameworks: '',
    Accounts: '',
    OrganizationUnits: '',
    Regions: ''
  },
  ReportPlanTags: {},
  IdempotencyToken: ''
});

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}}/audit/report-plans',
  headers: {'content-type': 'application/json'},
  data: {
    ReportPlanName: '',
    ReportPlanDescription: '',
    ReportDeliveryChannel: {S3BucketName: '', S3KeyPrefix: '', Formats: ''},
    ReportSetting: {
      ReportTemplate: '',
      FrameworkArns: '',
      NumberOfFrameworks: '',
      Accounts: '',
      OrganizationUnits: '',
      Regions: ''
    },
    ReportPlanTags: {},
    IdempotencyToken: ''
  }
};

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

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

const url = '{{baseUrl}}/audit/report-plans';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ReportPlanName":"","ReportPlanDescription":"","ReportDeliveryChannel":{"S3BucketName":"","S3KeyPrefix":"","Formats":""},"ReportSetting":{"ReportTemplate":"","FrameworkArns":"","NumberOfFrameworks":"","Accounts":"","OrganizationUnits":"","Regions":""},"ReportPlanTags":{},"IdempotencyToken":""}'
};

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 = @{ @"ReportPlanName": @"",
                              @"ReportPlanDescription": @"",
                              @"ReportDeliveryChannel": @{ @"S3BucketName": @"", @"S3KeyPrefix": @"", @"Formats": @"" },
                              @"ReportSetting": @{ @"ReportTemplate": @"", @"FrameworkArns": @"", @"NumberOfFrameworks": @"", @"Accounts": @"", @"OrganizationUnits": @"", @"Regions": @"" },
                              @"ReportPlanTags": @{  },
                              @"IdempotencyToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/audit/report-plans"]
                                                       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}}/audit/report-plans" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\n}" in

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

 "{{baseUrl}}/audit/report-plans",
  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([
    'ReportPlanName' => '',
    'ReportPlanDescription' => '',
    'ReportDeliveryChannel' => [
        'S3BucketName' => '',
        'S3KeyPrefix' => '',
        'Formats' => ''
    ],
    'ReportSetting' => [
        'ReportTemplate' => '',
        'FrameworkArns' => '',
        'NumberOfFrameworks' => '',
        'Accounts' => '',
        'OrganizationUnits' => '',
        'Regions' => ''
    ],
    'ReportPlanTags' => [
        
    ],
    'IdempotencyToken' => ''
  ]),
  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}}/audit/report-plans', [
  'body' => '{
  "ReportPlanName": "",
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "ReportPlanTags": {},
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/audit/report-plans');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReportPlanName' => '',
  'ReportPlanDescription' => '',
  'ReportDeliveryChannel' => [
    'S3BucketName' => '',
    'S3KeyPrefix' => '',
    'Formats' => ''
  ],
  'ReportSetting' => [
    'ReportTemplate' => '',
    'FrameworkArns' => '',
    'NumberOfFrameworks' => '',
    'Accounts' => '',
    'OrganizationUnits' => '',
    'Regions' => ''
  ],
  'ReportPlanTags' => [
    
  ],
  'IdempotencyToken' => ''
]));

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

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

append(json_encode([
  'ReportPlanName' => '',
  'ReportPlanDescription' => '',
  'ReportDeliveryChannel' => [
    'S3BucketName' => '',
    'S3KeyPrefix' => '',
    'Formats' => ''
  ],
  'ReportSetting' => [
    'ReportTemplate' => '',
    'FrameworkArns' => '',
    'NumberOfFrameworks' => '',
    'Accounts' => '',
    'OrganizationUnits' => '',
    'Regions' => ''
  ],
  'ReportPlanTags' => [
    
  ],
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/audit/report-plans');
$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}}/audit/report-plans' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReportPlanName": "",
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "ReportPlanTags": {},
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/report-plans' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReportPlanName": "",
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "ReportPlanTags": {},
  "IdempotencyToken": ""
}'

import http.client

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

payload = "{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/audit/report-plans", payload, headers)

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

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

import requests

url = "{{baseUrl}}/audit/report-plans"

payload = {
    "ReportPlanName": "",
    "ReportPlanDescription": "",
    "ReportDeliveryChannel": {
        "S3BucketName": "",
        "S3KeyPrefix": "",
        "Formats": ""
    },
    "ReportSetting": {
        "ReportTemplate": "",
        "FrameworkArns": "",
        "NumberOfFrameworks": "",
        "Accounts": "",
        "OrganizationUnits": "",
        "Regions": ""
    },
    "ReportPlanTags": {},
    "IdempotencyToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/report-plans"

payload <- "{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\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}}/audit/report-plans")

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  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\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/audit/report-plans') do |req|
  req.body = "{\n  \"ReportPlanName\": \"\",\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"ReportPlanTags\": {},\n  \"IdempotencyToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ReportPlanName": "",
        "ReportPlanDescription": "",
        "ReportDeliveryChannel": json!({
            "S3BucketName": "",
            "S3KeyPrefix": "",
            "Formats": ""
        }),
        "ReportSetting": json!({
            "ReportTemplate": "",
            "FrameworkArns": "",
            "NumberOfFrameworks": "",
            "Accounts": "",
            "OrganizationUnits": "",
            "Regions": ""
        }),
        "ReportPlanTags": json!({}),
        "IdempotencyToken": ""
    });

    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}}/audit/report-plans \
  --header 'content-type: application/json' \
  --data '{
  "ReportPlanName": "",
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "ReportPlanTags": {},
  "IdempotencyToken": ""
}'

echo '{
  "ReportPlanName": "",
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "ReportPlanTags": {},
  "IdempotencyToken": ""
}' |  \
  http POST {{baseUrl}}/audit/report-plans \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReportPlanName": "",\n  "ReportPlanDescription": "",\n  "ReportDeliveryChannel": {\n    "S3BucketName": "",\n    "S3KeyPrefix": "",\n    "Formats": ""\n  },\n  "ReportSetting": {\n    "ReportTemplate": "",\n    "FrameworkArns": "",\n    "NumberOfFrameworks": "",\n    "Accounts": "",\n    "OrganizationUnits": "",\n    "Regions": ""\n  },\n  "ReportPlanTags": {},\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/audit/report-plans

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ReportPlanName": "",
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": [
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  ],
  "ReportSetting": [
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  ],
  "ReportPlanTags": [],
  "IdempotencyToken": ""
] as [String : Any]

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

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

{{baseUrl}}/backup/plans/:backupPlanId

QUERY PARAMS

backupPlanId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/plans/:backupPlanId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/backup/plans/:backupPlanId")

require "http/client"

url = "{{baseUrl}}/backup/plans/:backupPlanId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/backup/plans/:backupPlanId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/backup/plans/:backupPlanId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/backup/plans/:backupPlanId');

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}}/backup/plans/:backupPlanId'
};

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

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

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

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

 "{{baseUrl}}/backup/plans/:backupPlanId",
  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}}/backup/plans/:backupPlanId');

echo $response->getBody();

setUrl('{{baseUrl}}/backup/plans/:backupPlanId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup/plans/:backupPlanId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/plans/:backupPlanId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/backup/plans/:backupPlanId")

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

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

import requests

url = "{{baseUrl}}/backup/plans/:backupPlanId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/plans/:backupPlanId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup/plans/:backupPlanId")

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/backup/plans/:backupPlanId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/backup/plans/:backupPlanId

http DELETE {{baseUrl}}/backup/plans/:backupPlanId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/backup/plans/:backupPlanId

import Foundation

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

{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId

QUERY PARAMS

backupPlanId

selectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")

require "http/client"

url = "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId"

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

var client = new RestClient("{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId"

	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/backup/plans/:backupPlanId/selections/:selectionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")
  .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}}/backup/plans/:backupPlanId/selections/:selectionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId'
};

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

const url = '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId';
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}}/backup/plans/:backupPlanId/selections/:selectionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId');

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}}/backup/plans/:backupPlanId/selections/:selectionId'
};

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

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

const url = '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId';
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}}/backup/plans/:backupPlanId/selections/:selectionId"]
                                                       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}}/backup/plans/:backupPlanId/selections/:selectionId" in

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

 "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId",
  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}}/backup/plans/:backupPlanId/selections/:selectionId');

echo $response->getBody();

setUrl('{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/backup/plans/:backupPlanId/selections/:selectionId")

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

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

import requests

url = "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")

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/backup/plans/:backupPlanId/selections/:selectionId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId";

    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}}/backup/plans/:backupPlanId/selections/:selectionId

http DELETE {{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")! 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 DeleteBackupVault

{{baseUrl}}/backup-vaults/:backupVaultName

QUERY PARAMS

backupVaultName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/backup-vaults/:backupVaultName")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName"

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

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/backup-vaults/:backupVaultName');

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}}/backup-vaults/:backupVaultName'
};

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

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

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

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

 "{{baseUrl}}/backup-vaults/:backupVaultName",
  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}}/backup-vaults/:backupVaultName');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/backup-vaults/:backupVaultName")

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

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

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName")

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/backup-vaults/:backupVaultName') do |req|
end

puts response.status
puts response.body

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

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

    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}}/backup-vaults/:backupVaultName

http DELETE {{baseUrl}}/backup-vaults/:backupVaultName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName

import Foundation

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

{{baseUrl}}/backup-vaults/:backupVaultName/access-policy

QUERY PARAMS

backupVaultName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"

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

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"

	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/backup-vaults/:backupVaultName/access-policy HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")
  .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}}/backup-vaults/:backupVaultName/access-policy');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy'
};

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy';
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}}/backup-vaults/:backupVaultName/access-policy',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy');

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}}/backup-vaults/:backupVaultName/access-policy'
};

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

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy';
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}}/backup-vaults/:backupVaultName/access-policy"]
                                                       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}}/backup-vaults/:backupVaultName/access-policy" in

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

 "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy",
  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}}/backup-vaults/:backupVaultName/access-policy');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/access-policy');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/access-policy');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/backup-vaults/:backupVaultName/access-policy")

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

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

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")

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/backup-vaults/:backupVaultName/access-policy') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy";

    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}}/backup-vaults/:backupVaultName/access-policy

http DELETE {{baseUrl}}/backup-vaults/:backupVaultName/access-policy

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/access-policy

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")! 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 DeleteBackupVaultLockConfiguration

{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock

QUERY PARAMS

backupVaultName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock"

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

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock"

	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/backup-vaults/:backupVaultName/vault-lock HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")
  .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}}/backup-vaults/:backupVaultName/vault-lock');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock'
};

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock';
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}}/backup-vaults/:backupVaultName/vault-lock',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock');

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}}/backup-vaults/:backupVaultName/vault-lock'
};

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

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock';
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}}/backup-vaults/:backupVaultName/vault-lock"]
                                                       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}}/backup-vaults/:backupVaultName/vault-lock" in

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

 "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock",
  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}}/backup-vaults/:backupVaultName/vault-lock');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/backup-vaults/:backupVaultName/vault-lock")

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

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

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")

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/backup-vaults/:backupVaultName/vault-lock') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock";

    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}}/backup-vaults/:backupVaultName/vault-lock

http DELETE {{baseUrl}}/backup-vaults/:backupVaultName/vault-lock

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/vault-lock

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")! 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 DeleteBackupVaultNotifications

{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration

QUERY PARAMS

backupVaultName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"

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

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"

	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/backup-vaults/:backupVaultName/notification-configuration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration'
};

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration';
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}}/backup-vaults/:backupVaultName/notification-configuration',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup-vaults/:backupVaultName/notification-configuration',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration'
};

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

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration';
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}}/backup-vaults/:backupVaultName/notification-configuration"]
                                                       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}}/backup-vaults/:backupVaultName/notification-configuration" in

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

 "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration",
  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}}/backup-vaults/:backupVaultName/notification-configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/backup-vaults/:backupVaultName/notification-configuration")

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

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

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")

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/backup-vaults/:backupVaultName/notification-configuration') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration";

    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}}/backup-vaults/:backupVaultName/notification-configuration

http DELETE {{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")! 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 DeleteFramework

{{baseUrl}}/audit/frameworks/:frameworkName

QUERY PARAMS

frameworkName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/frameworks/:frameworkName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/audit/frameworks/:frameworkName")

require "http/client"

url = "{{baseUrl}}/audit/frameworks/:frameworkName"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/audit/frameworks/:frameworkName"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/audit/frameworks/:frameworkName'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/audit/frameworks/:frameworkName")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/audit/frameworks/:frameworkName');

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}}/audit/frameworks/:frameworkName'
};

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

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

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

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

 "{{baseUrl}}/audit/frameworks/:frameworkName",
  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}}/audit/frameworks/:frameworkName');

echo $response->getBody();

setUrl('{{baseUrl}}/audit/frameworks/:frameworkName');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/frameworks/:frameworkName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/frameworks/:frameworkName' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/audit/frameworks/:frameworkName")

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

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

import requests

url = "{{baseUrl}}/audit/frameworks/:frameworkName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/frameworks/:frameworkName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/frameworks/:frameworkName")

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/audit/frameworks/:frameworkName') do |req|
end

puts response.status
puts response.body

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

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

    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}}/audit/frameworks/:frameworkName

http DELETE {{baseUrl}}/audit/frameworks/:frameworkName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/audit/frameworks/:frameworkName

import Foundation

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

{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn

QUERY PARAMS

backupVaultName

recoveryPointArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"

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

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"

	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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"))
    .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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn'
};

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn';
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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn',
  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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');

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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn'
};

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

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn';
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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"]
                                                       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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn" in

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

 "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn",
  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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")

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

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

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")

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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn";

    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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn

http DELETE {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")! 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 DeleteReportPlan

{{baseUrl}}/audit/report-plans/:reportPlanName

QUERY PARAMS

reportPlanName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/report-plans/:reportPlanName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/audit/report-plans/:reportPlanName")

require "http/client"

url = "{{baseUrl}}/audit/report-plans/:reportPlanName"

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

var client = new RestClient("{{baseUrl}}/audit/report-plans/:reportPlanName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/audit/report-plans/:reportPlanName"

	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/audit/report-plans/:reportPlanName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/audit/report-plans/:reportPlanName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/audit/report-plans/:reportPlanName'
};

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

const url = '{{baseUrl}}/audit/report-plans/:reportPlanName';
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}}/audit/report-plans/:reportPlanName',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/audit/report-plans/:reportPlanName")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/audit/report-plans/:reportPlanName');

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}}/audit/report-plans/:reportPlanName'
};

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

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

const url = '{{baseUrl}}/audit/report-plans/:reportPlanName';
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}}/audit/report-plans/:reportPlanName"]
                                                       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}}/audit/report-plans/:reportPlanName" in

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

 "{{baseUrl}}/audit/report-plans/:reportPlanName",
  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}}/audit/report-plans/:reportPlanName');

echo $response->getBody();

setUrl('{{baseUrl}}/audit/report-plans/:reportPlanName');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/audit/report-plans/:reportPlanName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/report-plans/:reportPlanName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/report-plans/:reportPlanName' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/audit/report-plans/:reportPlanName")

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

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

import requests

url = "{{baseUrl}}/audit/report-plans/:reportPlanName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/report-plans/:reportPlanName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/report-plans/:reportPlanName")

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/audit/report-plans/:reportPlanName') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/report-plans/:reportPlanName";

    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}}/audit/report-plans/:reportPlanName

http DELETE {{baseUrl}}/audit/report-plans/:reportPlanName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/audit/report-plans/:reportPlanName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/report-plans/:reportPlanName")! 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 DescribeBackupJob

{{baseUrl}}/backup-jobs/:backupJobId

QUERY PARAMS

backupJobId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-jobs/:backupJobId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/backup-jobs/:backupJobId")

require "http/client"

url = "{{baseUrl}}/backup-jobs/:backupJobId"

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

var client = new RestClient("{{baseUrl}}/backup-jobs/:backupJobId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup-jobs/:backupJobId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/backup-jobs/:backupJobId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-jobs/:backupJobId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup-jobs/:backupJobId');

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}}/backup-jobs/:backupJobId'};

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

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

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

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

 "{{baseUrl}}/backup-jobs/:backupJobId",
  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}}/backup-jobs/:backupJobId');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-jobs/:backupJobId');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-jobs/:backupJobId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-jobs/:backupJobId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/backup-jobs/:backupJobId")

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

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

import requests

url = "{{baseUrl}}/backup-jobs/:backupJobId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-jobs/:backupJobId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-jobs/:backupJobId")

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/backup-jobs/:backupJobId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/backup-jobs/:backupJobId

http GET {{baseUrl}}/backup-jobs/:backupJobId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup-jobs/:backupJobId

import Foundation

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

{{baseUrl}}/backup-vaults/:backupVaultName

QUERY PARAMS

backupVaultName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/backup-vaults/:backupVaultName")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName"

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

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup-vaults/:backupVaultName');

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}}/backup-vaults/:backupVaultName'
};

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

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

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

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

 "{{baseUrl}}/backup-vaults/:backupVaultName",
  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}}/backup-vaults/:backupVaultName');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/backup-vaults/:backupVaultName")

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

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

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName")

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/backup-vaults/:backupVaultName') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/backup-vaults/:backupVaultName

http GET {{baseUrl}}/backup-vaults/:backupVaultName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName

import Foundation

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

{{baseUrl}}/copy-jobs/:copyJobId

QUERY PARAMS

copyJobId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/copy-jobs/:copyJobId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/copy-jobs/:copyJobId")

require "http/client"

url = "{{baseUrl}}/copy-jobs/:copyJobId"

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

var client = new RestClient("{{baseUrl}}/copy-jobs/:copyJobId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/copy-jobs/:copyJobId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/copy-jobs/:copyJobId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/copy-jobs/:copyJobId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/copy-jobs/:copyJobId');

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}}/copy-jobs/:copyJobId'};

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

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

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

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

 "{{baseUrl}}/copy-jobs/:copyJobId",
  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}}/copy-jobs/:copyJobId');

echo $response->getBody();

setUrl('{{baseUrl}}/copy-jobs/:copyJobId');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/copy-jobs/:copyJobId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/copy-jobs/:copyJobId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/copy-jobs/:copyJobId")

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

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

import requests

url = "{{baseUrl}}/copy-jobs/:copyJobId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/copy-jobs/:copyJobId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/copy-jobs/:copyJobId")

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/copy-jobs/:copyJobId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/copy-jobs/:copyJobId

http GET {{baseUrl}}/copy-jobs/:copyJobId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/copy-jobs/:copyJobId

import Foundation

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

{{baseUrl}}/audit/frameworks/:frameworkName

QUERY PARAMS

frameworkName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/frameworks/:frameworkName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/audit/frameworks/:frameworkName")

require "http/client"

url = "{{baseUrl}}/audit/frameworks/:frameworkName"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/audit/frameworks/:frameworkName"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/audit/frameworks/:frameworkName'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/audit/frameworks/:frameworkName")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/audit/frameworks/:frameworkName');

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}}/audit/frameworks/:frameworkName'
};

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

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

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

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

 "{{baseUrl}}/audit/frameworks/:frameworkName",
  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}}/audit/frameworks/:frameworkName');

echo $response->getBody();

setUrl('{{baseUrl}}/audit/frameworks/:frameworkName');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/frameworks/:frameworkName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/frameworks/:frameworkName' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/audit/frameworks/:frameworkName")

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

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

import requests

url = "{{baseUrl}}/audit/frameworks/:frameworkName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/frameworks/:frameworkName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/frameworks/:frameworkName")

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/audit/frameworks/:frameworkName') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/audit/frameworks/:frameworkName

http GET {{baseUrl}}/audit/frameworks/:frameworkName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/audit/frameworks/:frameworkName

import Foundation

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

{{baseUrl}}/global-settings

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/global-settings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/global-settings")

require "http/client"

url = "{{baseUrl}}/global-settings"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/global-settings"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-settings');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/global-settings")

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

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

import requests

url = "{{baseUrl}}/global-settings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-settings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-settings")

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

puts response.status
puts response.body

use reqwest;

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

    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}}/global-settings

http GET {{baseUrl}}/global-settings

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

import Foundation

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

{{baseUrl}}/resources/: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}}/resources/:resourceArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/resources/:resourceArn")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/resources/: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/resources/:resourceArn HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/resources/: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}}/resources/: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}}/resources/:resourceArn" in

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

 "{{baseUrl}}/resources/: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}}/resources/:resourceArn');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/:resourceArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/:resourceArn' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/resources/:resourceArn")

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

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

import requests

url = "{{baseUrl}}/resources/:resourceArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/:resourceArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/: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/resources/:resourceArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/: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}}/resources/:resourceArn

http GET {{baseUrl}}/resources/:resourceArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resources/:resourceArn

import Foundation

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

GET DescribeRecoveryPoint

{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn

QUERY PARAMS

backupVaultName

recoveryPointArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"

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

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"

	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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"))
    .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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn'
};

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn';
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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');

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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn'
};

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

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn';
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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"]
                                                       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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn" in

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

 "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn",
  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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")

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

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

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")

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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn";

    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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn

http GET {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")! 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 DescribeRegionSettings

{{baseUrl}}/account-settings

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account-settings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/account-settings")

require "http/client"

url = "{{baseUrl}}/account-settings"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/account-settings"

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

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

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

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

}

GET /baseUrl/account-settings HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/account-settings');

xhr.send(data);

import axios from 'axios';

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

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

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/account-settings');

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

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

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

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

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

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

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

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/account-settings" in

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

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

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/account-settings');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/account-settings")

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

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

import requests

url = "{{baseUrl}}/account-settings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account-settings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/account-settings")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/account-settings') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/account-settings

http GET {{baseUrl}}/account-settings

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

import Foundation

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

{{baseUrl}}/audit/report-jobs/:reportJobId

QUERY PARAMS

reportJobId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/report-jobs/:reportJobId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/audit/report-jobs/:reportJobId")

require "http/client"

url = "{{baseUrl}}/audit/report-jobs/:reportJobId"

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

var client = new RestClient("{{baseUrl}}/audit/report-jobs/:reportJobId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/audit/report-jobs/:reportJobId"

	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/audit/report-jobs/:reportJobId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/audit/report-jobs/:reportJobId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/audit/report-jobs/:reportJobId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/audit/report-jobs/:reportJobId');

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}}/audit/report-jobs/:reportJobId'
};

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

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

const url = '{{baseUrl}}/audit/report-jobs/:reportJobId';
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}}/audit/report-jobs/:reportJobId"]
                                                       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}}/audit/report-jobs/:reportJobId" in

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

 "{{baseUrl}}/audit/report-jobs/:reportJobId",
  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}}/audit/report-jobs/:reportJobId');

echo $response->getBody();

setUrl('{{baseUrl}}/audit/report-jobs/:reportJobId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/audit/report-jobs/:reportJobId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/report-jobs/:reportJobId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/report-jobs/:reportJobId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/audit/report-jobs/:reportJobId")

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

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

import requests

url = "{{baseUrl}}/audit/report-jobs/:reportJobId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/report-jobs/:reportJobId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/report-jobs/:reportJobId")

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/audit/report-jobs/:reportJobId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/report-jobs/:reportJobId";

    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}}/audit/report-jobs/:reportJobId

http GET {{baseUrl}}/audit/report-jobs/:reportJobId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/audit/report-jobs/:reportJobId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/report-jobs/:reportJobId")! 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 DescribeReportPlan

{{baseUrl}}/audit/report-plans/:reportPlanName

QUERY PARAMS

reportPlanName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/report-plans/:reportPlanName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/audit/report-plans/:reportPlanName")

require "http/client"

url = "{{baseUrl}}/audit/report-plans/:reportPlanName"

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

var client = new RestClient("{{baseUrl}}/audit/report-plans/:reportPlanName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/audit/report-plans/:reportPlanName"

	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/audit/report-plans/:reportPlanName HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/audit/report-plans/:reportPlanName'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/audit/report-plans/:reportPlanName")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/audit/report-plans/:reportPlanName');

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}}/audit/report-plans/:reportPlanName'
};

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

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

const url = '{{baseUrl}}/audit/report-plans/:reportPlanName';
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}}/audit/report-plans/:reportPlanName"]
                                                       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}}/audit/report-plans/:reportPlanName" in

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

 "{{baseUrl}}/audit/report-plans/:reportPlanName",
  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}}/audit/report-plans/:reportPlanName');

echo $response->getBody();

setUrl('{{baseUrl}}/audit/report-plans/:reportPlanName');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/audit/report-plans/:reportPlanName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/report-plans/:reportPlanName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/report-plans/:reportPlanName' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/audit/report-plans/:reportPlanName")

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

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

import requests

url = "{{baseUrl}}/audit/report-plans/:reportPlanName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/report-plans/:reportPlanName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/report-plans/:reportPlanName")

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/audit/report-plans/:reportPlanName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/report-plans/:reportPlanName";

    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}}/audit/report-plans/:reportPlanName

http GET {{baseUrl}}/audit/report-plans/:reportPlanName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/audit/report-plans/:reportPlanName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/report-plans/:reportPlanName")! 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 DescribeRestoreJob

{{baseUrl}}/restore-jobs/:restoreJobId

QUERY PARAMS

restoreJobId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restore-jobs/:restoreJobId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/restore-jobs/:restoreJobId")

require "http/client"

url = "{{baseUrl}}/restore-jobs/:restoreJobId"

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

var client = new RestClient("{{baseUrl}}/restore-jobs/:restoreJobId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/restore-jobs/:restoreJobId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/restore-jobs/:restoreJobId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restore-jobs/:restoreJobId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restore-jobs/:restoreJobId');

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}}/restore-jobs/:restoreJobId'};

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

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

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

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

 "{{baseUrl}}/restore-jobs/:restoreJobId",
  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}}/restore-jobs/:restoreJobId');

echo $response->getBody();

setUrl('{{baseUrl}}/restore-jobs/:restoreJobId');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restore-jobs/:restoreJobId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restore-jobs/:restoreJobId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/restore-jobs/:restoreJobId")

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

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

import requests

url = "{{baseUrl}}/restore-jobs/:restoreJobId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restore-jobs/:restoreJobId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restore-jobs/:restoreJobId")

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/restore-jobs/:restoreJobId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/restore-jobs/:restoreJobId

http GET {{baseUrl}}/restore-jobs/:restoreJobId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restore-jobs/:restoreJobId

import Foundation

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

{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate

QUERY PARAMS

backupVaultName

recoveryPointArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate"

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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate"

	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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate"))
    .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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate")
  .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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate'
};

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate';
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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate',
  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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate');

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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate'
};

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

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate';
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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate"]
                                                       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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate" in

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

 "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate",
  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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate")

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

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

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate")

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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate";

    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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate

http POST {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/disassociate")! 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()

DELETE DisassociateRecoveryPointFromParent

{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation

QUERY PARAMS

backupVaultName

recoveryPointArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation"

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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation"

	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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation"))
    .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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation")
  .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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation'
};

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation';
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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation',
  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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation');

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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation'
};

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

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

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation';
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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation"]
                                                       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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation" in

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

 "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation",
  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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation")

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

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

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation")

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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation";

    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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation

http DELETE {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/parentAssociation")! 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 ExportBackupPlanTemplate

{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/

QUERY PARAMS

backupPlanId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/")

require "http/client"

url = "{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/"

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

var client = new RestClient("{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/"

	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/backup/plans/:backupPlanId/toTemplate/ HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/');

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}}/backup/plans/:backupPlanId/toTemplate/'
};

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

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

const url = '{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/';
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}}/backup/plans/:backupPlanId/toTemplate/"]
                                                       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}}/backup/plans/:backupPlanId/toTemplate/" in

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

 "{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/",
  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}}/backup/plans/:backupPlanId/toTemplate/');

echo $response->getBody();

setUrl('{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/backup/plans/:backupPlanId/toTemplate/")

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

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

import requests

url = "{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/")

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/backup/plans/:backupPlanId/toTemplate/') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/backup/plans/:backupPlanId/toTemplate/

http GET {{baseUrl}}/backup/plans/:backupPlanId/toTemplate/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup/plans/:backupPlanId/toTemplate/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup/plans/:backupPlanId/toTemplate/")! 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 GetBackupPlan

{{baseUrl}}/backup/plans/:backupPlanId/

QUERY PARAMS

backupPlanId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/plans/:backupPlanId/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/backup/plans/:backupPlanId/")

require "http/client"

url = "{{baseUrl}}/backup/plans/:backupPlanId/"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/backup/plans/:backupPlanId/"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/backup/plans/:backupPlanId/'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId/")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup/plans/:backupPlanId/');

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}}/backup/plans/:backupPlanId/'};

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

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

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

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

 "{{baseUrl}}/backup/plans/:backupPlanId/",
  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}}/backup/plans/:backupPlanId/');

echo $response->getBody();

setUrl('{{baseUrl}}/backup/plans/:backupPlanId/');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup/plans/:backupPlanId/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/plans/:backupPlanId/' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/backup/plans/:backupPlanId/")

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

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

import requests

url = "{{baseUrl}}/backup/plans/:backupPlanId/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/plans/:backupPlanId/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup/plans/:backupPlanId/")

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/backup/plans/:backupPlanId/') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/backup/plans/:backupPlanId/

http GET {{baseUrl}}/backup/plans/:backupPlanId/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup/plans/:backupPlanId/

import Foundation

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

{{baseUrl}}/backup/template/json/toPlan

BODY json

{
  "BackupPlanTemplateJson": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/template/json/toPlan");

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  \"BackupPlanTemplateJson\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/backup/template/json/toPlan" {:content-type :json
                                                                        :form-params {:BackupPlanTemplateJson ""}})

require "http/client"

url = "{{baseUrl}}/backup/template/json/toPlan"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"BackupPlanTemplateJson\": \"\"\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}}/backup/template/json/toPlan"),
    Content = new StringContent("{\n  \"BackupPlanTemplateJson\": \"\"\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}}/backup/template/json/toPlan");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BackupPlanTemplateJson\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup/template/json/toPlan"

	payload := strings.NewReader("{\n  \"BackupPlanTemplateJson\": \"\"\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/backup/template/json/toPlan HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "BackupPlanTemplateJson": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backup/template/json/toPlan")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BackupPlanTemplateJson\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup/template/json/toPlan"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"BackupPlanTemplateJson\": \"\"\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  \"BackupPlanTemplateJson\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/backup/template/json/toPlan")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/backup/template/json/toPlan")
  .header("content-type", "application/json")
  .body("{\n  \"BackupPlanTemplateJson\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  BackupPlanTemplateJson: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/backup/template/json/toPlan');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/backup/template/json/toPlan',
  headers: {'content-type': 'application/json'},
  data: {BackupPlanTemplateJson: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup/template/json/toPlan';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"BackupPlanTemplateJson":""}'
};

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}}/backup/template/json/toPlan',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BackupPlanTemplateJson": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"BackupPlanTemplateJson\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/backup/template/json/toPlan")
  .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/backup/template/json/toPlan',
  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({BackupPlanTemplateJson: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/backup/template/json/toPlan',
  headers: {'content-type': 'application/json'},
  body: {BackupPlanTemplateJson: ''},
  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}}/backup/template/json/toPlan');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  BackupPlanTemplateJson: ''
});

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}}/backup/template/json/toPlan',
  headers: {'content-type': 'application/json'},
  data: {BackupPlanTemplateJson: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup/template/json/toPlan';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"BackupPlanTemplateJson":""}'
};

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 = @{ @"BackupPlanTemplateJson": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backup/template/json/toPlan"]
                                                       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}}/backup/template/json/toPlan" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"BackupPlanTemplateJson\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup/template/json/toPlan",
  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([
    'BackupPlanTemplateJson' => ''
  ]),
  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}}/backup/template/json/toPlan', [
  'body' => '{
  "BackupPlanTemplateJson": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/backup/template/json/toPlan');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BackupPlanTemplateJson' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'BackupPlanTemplateJson' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backup/template/json/toPlan');
$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}}/backup/template/json/toPlan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BackupPlanTemplateJson": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/template/json/toPlan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BackupPlanTemplateJson": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"BackupPlanTemplateJson\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/backup/template/json/toPlan", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup/template/json/toPlan"

payload = { "BackupPlanTemplateJson": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/template/json/toPlan"

payload <- "{\n  \"BackupPlanTemplateJson\": \"\"\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}}/backup/template/json/toPlan")

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  \"BackupPlanTemplateJson\": \"\"\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/backup/template/json/toPlan') do |req|
  req.body = "{\n  \"BackupPlanTemplateJson\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup/template/json/toPlan";

    let payload = json!({"BackupPlanTemplateJson": ""});

    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}}/backup/template/json/toPlan \
  --header 'content-type: application/json' \
  --data '{
  "BackupPlanTemplateJson": ""
}'

echo '{
  "BackupPlanTemplateJson": ""
}' |  \
  http POST {{baseUrl}}/backup/template/json/toPlan \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "BackupPlanTemplateJson": ""\n}' \
  --output-document \
  - {{baseUrl}}/backup/template/json/toPlan

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["BackupPlanTemplateJson": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup/template/json/toPlan")! 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 GetBackupPlanFromTemplate

{{baseUrl}}/backup/template/plans/:templateId/toPlan

QUERY PARAMS

templateId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/template/plans/:templateId/toPlan");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup/template/plans/:templateId/toPlan")

require "http/client"

url = "{{baseUrl}}/backup/template/plans/:templateId/toPlan"

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}}/backup/template/plans/:templateId/toPlan"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup/template/plans/:templateId/toPlan");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup/template/plans/:templateId/toPlan"

	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/backup/template/plans/:templateId/toPlan HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup/template/plans/:templateId/toPlan")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup/template/plans/:templateId/toPlan"))
    .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}}/backup/template/plans/:templateId/toPlan")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup/template/plans/:templateId/toPlan")
  .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}}/backup/template/plans/:templateId/toPlan');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup/template/plans/:templateId/toPlan'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup/template/plans/:templateId/toPlan';
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}}/backup/template/plans/:templateId/toPlan',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup/template/plans/:templateId/toPlan")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup/template/plans/:templateId/toPlan',
  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}}/backup/template/plans/:templateId/toPlan'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup/template/plans/:templateId/toPlan');

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}}/backup/template/plans/:templateId/toPlan'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup/template/plans/:templateId/toPlan';
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}}/backup/template/plans/:templateId/toPlan"]
                                                       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}}/backup/template/plans/:templateId/toPlan" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup/template/plans/:templateId/toPlan",
  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}}/backup/template/plans/:templateId/toPlan');

echo $response->getBody();

setUrl('{{baseUrl}}/backup/template/plans/:templateId/toPlan');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup/template/plans/:templateId/toPlan');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup/template/plans/:templateId/toPlan' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/template/plans/:templateId/toPlan' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup/template/plans/:templateId/toPlan")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup/template/plans/:templateId/toPlan"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/template/plans/:templateId/toPlan"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup/template/plans/:templateId/toPlan")

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/backup/template/plans/:templateId/toPlan') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup/template/plans/:templateId/toPlan";

    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}}/backup/template/plans/:templateId/toPlan

http GET {{baseUrl}}/backup/template/plans/:templateId/toPlan

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup/template/plans/:templateId/toPlan

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup/template/plans/:templateId/toPlan")! 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 GetBackupSelection

{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId

QUERY PARAMS

backupPlanId

selectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")

require "http/client"

url = "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId"

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}}/backup/plans/:backupPlanId/selections/:selectionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId"

	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/backup/plans/:backupPlanId/selections/:selectionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId"))
    .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}}/backup/plans/:backupPlanId/selections/:selectionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")
  .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}}/backup/plans/:backupPlanId/selections/:selectionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId';
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}}/backup/plans/:backupPlanId/selections/:selectionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup/plans/:backupPlanId/selections/:selectionId',
  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}}/backup/plans/:backupPlanId/selections/:selectionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId');

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}}/backup/plans/:backupPlanId/selections/:selectionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId';
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}}/backup/plans/:backupPlanId/selections/:selectionId"]
                                                       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}}/backup/plans/:backupPlanId/selections/:selectionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId",
  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}}/backup/plans/:backupPlanId/selections/:selectionId');

echo $response->getBody();

setUrl('{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup/plans/:backupPlanId/selections/:selectionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")

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/backup/plans/:backupPlanId/selections/:selectionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId";

    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}}/backup/plans/:backupPlanId/selections/:selectionId

http GET {{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup/plans/:backupPlanId/selections/:selectionId")! 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 GetBackupVaultAccessPolicy

{{baseUrl}}/backup-vaults/:backupVaultName/access-policy

QUERY PARAMS

backupVaultName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"

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}}/backup-vaults/:backupVaultName/access-policy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"

	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/backup-vaults/:backupVaultName/access-policy HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"))
    .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}}/backup-vaults/:backupVaultName/access-policy")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")
  .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}}/backup-vaults/:backupVaultName/access-policy');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy';
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}}/backup-vaults/:backupVaultName/access-policy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup-vaults/:backupVaultName/access-policy',
  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}}/backup-vaults/:backupVaultName/access-policy'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy');

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}}/backup-vaults/:backupVaultName/access-policy'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy';
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}}/backup-vaults/:backupVaultName/access-policy"]
                                                       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}}/backup-vaults/:backupVaultName/access-policy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy",
  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}}/backup-vaults/:backupVaultName/access-policy');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/access-policy');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/access-policy');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup-vaults/:backupVaultName/access-policy")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")

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/backup-vaults/:backupVaultName/access-policy') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy";

    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}}/backup-vaults/:backupVaultName/access-policy

http GET {{baseUrl}}/backup-vaults/:backupVaultName/access-policy

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/access-policy

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")! 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 GetBackupVaultNotifications

{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration

QUERY PARAMS

backupVaultName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/backup-vaults/:backupVaultName/notification-configuration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup-vaults/:backupVaultName/notification-configuration',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup-vaults/:backupVaultName/notification-configuration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/backup-vaults/:backupVaultName/notification-configuration') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration

http GET {{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GetLegalHold

{{baseUrl}}/legal-holds/:legalHoldId/

QUERY PARAMS

legalHoldId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/legal-holds/:legalHoldId/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/legal-holds/:legalHoldId/")

require "http/client"

url = "{{baseUrl}}/legal-holds/:legalHoldId/"

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}}/legal-holds/:legalHoldId/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/legal-holds/:legalHoldId/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/legal-holds/:legalHoldId/"

	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/legal-holds/:legalHoldId/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/legal-holds/:legalHoldId/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/legal-holds/:legalHoldId/"))
    .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}}/legal-holds/:legalHoldId/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/legal-holds/:legalHoldId/")
  .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}}/legal-holds/:legalHoldId/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/legal-holds/:legalHoldId/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/legal-holds/:legalHoldId/';
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}}/legal-holds/:legalHoldId/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/legal-holds/:legalHoldId/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/legal-holds/:legalHoldId/',
  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}}/legal-holds/:legalHoldId/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/legal-holds/:legalHoldId/');

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}}/legal-holds/:legalHoldId/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/legal-holds/:legalHoldId/';
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}}/legal-holds/:legalHoldId/"]
                                                       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}}/legal-holds/:legalHoldId/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/legal-holds/:legalHoldId/",
  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}}/legal-holds/:legalHoldId/');

echo $response->getBody();

setUrl('{{baseUrl}}/legal-holds/:legalHoldId/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/legal-holds/:legalHoldId/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/legal-holds/:legalHoldId/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/legal-holds/:legalHoldId/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/legal-holds/:legalHoldId/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/legal-holds/:legalHoldId/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/legal-holds/:legalHoldId/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/legal-holds/:legalHoldId/")

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/legal-holds/:legalHoldId/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/legal-holds/:legalHoldId/";

    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}}/legal-holds/:legalHoldId/

http GET {{baseUrl}}/legal-holds/:legalHoldId/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/legal-holds/:legalHoldId/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/legal-holds/:legalHoldId/")! 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 GetRecoveryPointRestoreMetadata

{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata

QUERY PARAMS

backupVaultName

recoveryPointArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata"

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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata"

	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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata"))
    .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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata")
  .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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata';
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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata',
  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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata');

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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata';
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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata"]
                                                       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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata",
  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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata")

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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata";

    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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata

http GET {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn/restore-metadata")! 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 GetSupportedResourceTypes

{{baseUrl}}/supported-resource-types

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/supported-resource-types");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/supported-resource-types")

require "http/client"

url = "{{baseUrl}}/supported-resource-types"

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}}/supported-resource-types"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/supported-resource-types");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/supported-resource-types"

	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/supported-resource-types HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/supported-resource-types")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/supported-resource-types"))
    .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}}/supported-resource-types")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/supported-resource-types")
  .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}}/supported-resource-types');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/supported-resource-types'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/supported-resource-types';
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}}/supported-resource-types',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/supported-resource-types")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/supported-resource-types',
  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}}/supported-resource-types'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/supported-resource-types');

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}}/supported-resource-types'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/supported-resource-types';
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}}/supported-resource-types"]
                                                       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}}/supported-resource-types" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/supported-resource-types",
  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}}/supported-resource-types');

echo $response->getBody();

setUrl('{{baseUrl}}/supported-resource-types');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/supported-resource-types');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/supported-resource-types' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/supported-resource-types' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/supported-resource-types")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/supported-resource-types"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/supported-resource-types"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/supported-resource-types")

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/supported-resource-types') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/supported-resource-types";

    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}}/supported-resource-types

http GET {{baseUrl}}/supported-resource-types

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/supported-resource-types

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/supported-resource-types")! 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 ListBackupJobs

{{baseUrl}}/backup-jobs/

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-jobs/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup-jobs/")

require "http/client"

url = "{{baseUrl}}/backup-jobs/"

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}}/backup-jobs/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup-jobs/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-jobs/"

	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/backup-jobs/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup-jobs/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-jobs/"))
    .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}}/backup-jobs/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup-jobs/")
  .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}}/backup-jobs/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/backup-jobs/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-jobs/';
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}}/backup-jobs/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-jobs/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup-jobs/',
  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}}/backup-jobs/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup-jobs/');

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}}/backup-jobs/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-jobs/';
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}}/backup-jobs/"]
                                                       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}}/backup-jobs/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-jobs/",
  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}}/backup-jobs/');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-jobs/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup-jobs/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-jobs/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-jobs/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup-jobs/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-jobs/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-jobs/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-jobs/")

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/backup-jobs/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-jobs/";

    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}}/backup-jobs/

http GET {{baseUrl}}/backup-jobs/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup-jobs/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-jobs/")! 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 ListBackupPlanTemplates

{{baseUrl}}/backup/template/plans

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/template/plans");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup/template/plans")

require "http/client"

url = "{{baseUrl}}/backup/template/plans"

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}}/backup/template/plans"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup/template/plans");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup/template/plans"

	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/backup/template/plans HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup/template/plans")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup/template/plans"))
    .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}}/backup/template/plans")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup/template/plans")
  .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}}/backup/template/plans');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/backup/template/plans'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup/template/plans';
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}}/backup/template/plans',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup/template/plans")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup/template/plans',
  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}}/backup/template/plans'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup/template/plans');

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}}/backup/template/plans'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup/template/plans';
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}}/backup/template/plans"]
                                                       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}}/backup/template/plans" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup/template/plans",
  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}}/backup/template/plans');

echo $response->getBody();

setUrl('{{baseUrl}}/backup/template/plans');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup/template/plans');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup/template/plans' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/template/plans' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup/template/plans")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup/template/plans"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/template/plans"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup/template/plans")

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/backup/template/plans') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup/template/plans";

    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}}/backup/template/plans

http GET {{baseUrl}}/backup/template/plans

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup/template/plans

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup/template/plans")! 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 ListBackupPlanVersions

{{baseUrl}}/backup/plans/:backupPlanId/versions/

QUERY PARAMS

backupPlanId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/plans/:backupPlanId/versions/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup/plans/:backupPlanId/versions/")

require "http/client"

url = "{{baseUrl}}/backup/plans/:backupPlanId/versions/"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/backup/plans/:backupPlanId/versions/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup/plans/:backupPlanId/versions/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup/plans/:backupPlanId/versions/"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/backup/plans/:backupPlanId/versions/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup/plans/:backupPlanId/versions/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup/plans/:backupPlanId/versions/"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId/versions/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup/plans/:backupPlanId/versions/")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/backup/plans/:backupPlanId/versions/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup/plans/:backupPlanId/versions/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup/plans/:backupPlanId/versions/';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/backup/plans/:backupPlanId/versions/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId/versions/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup/plans/:backupPlanId/versions/',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup/plans/:backupPlanId/versions/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup/plans/:backupPlanId/versions/');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup/plans/:backupPlanId/versions/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup/plans/:backupPlanId/versions/';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backup/plans/:backupPlanId/versions/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/backup/plans/:backupPlanId/versions/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup/plans/:backupPlanId/versions/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/backup/plans/:backupPlanId/versions/');

echo $response->getBody();

setUrl('{{baseUrl}}/backup/plans/:backupPlanId/versions/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup/plans/:backupPlanId/versions/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup/plans/:backupPlanId/versions/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/plans/:backupPlanId/versions/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup/plans/:backupPlanId/versions/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup/plans/:backupPlanId/versions/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/plans/:backupPlanId/versions/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup/plans/:backupPlanId/versions/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/backup/plans/:backupPlanId/versions/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup/plans/:backupPlanId/versions/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/backup/plans/:backupPlanId/versions/

http GET {{baseUrl}}/backup/plans/:backupPlanId/versions/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup/plans/:backupPlanId/versions/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup/plans/:backupPlanId/versions/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListBackupPlans

{{baseUrl}}/backup/plans/

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/plans/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup/plans/")

require "http/client"

url = "{{baseUrl}}/backup/plans/"

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}}/backup/plans/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup/plans/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup/plans/"

	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/backup/plans/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup/plans/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup/plans/"))
    .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}}/backup/plans/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup/plans/")
  .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}}/backup/plans/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/backup/plans/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup/plans/';
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}}/backup/plans/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup/plans/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup/plans/',
  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}}/backup/plans/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup/plans/');

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}}/backup/plans/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup/plans/';
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}}/backup/plans/"]
                                                       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}}/backup/plans/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup/plans/",
  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}}/backup/plans/');

echo $response->getBody();

setUrl('{{baseUrl}}/backup/plans/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup/plans/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup/plans/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/plans/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup/plans/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup/plans/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/plans/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup/plans/")

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/backup/plans/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup/plans/";

    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}}/backup/plans/

http GET {{baseUrl}}/backup/plans/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup/plans/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup/plans/")! 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 ListBackupSelections

{{baseUrl}}/backup/plans/:backupPlanId/selections/

QUERY PARAMS

backupPlanId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/plans/:backupPlanId/selections/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup/plans/:backupPlanId/selections/")

require "http/client"

url = "{{baseUrl}}/backup/plans/:backupPlanId/selections/"

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}}/backup/plans/:backupPlanId/selections/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup/plans/:backupPlanId/selections/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup/plans/:backupPlanId/selections/"

	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/backup/plans/:backupPlanId/selections/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup/plans/:backupPlanId/selections/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup/plans/:backupPlanId/selections/"))
    .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}}/backup/plans/:backupPlanId/selections/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup/plans/:backupPlanId/selections/")
  .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}}/backup/plans/:backupPlanId/selections/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup/plans/:backupPlanId/selections/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup/plans/:backupPlanId/selections/';
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}}/backup/plans/:backupPlanId/selections/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId/selections/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup/plans/:backupPlanId/selections/',
  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}}/backup/plans/:backupPlanId/selections/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup/plans/:backupPlanId/selections/');

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}}/backup/plans/:backupPlanId/selections/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup/plans/:backupPlanId/selections/';
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}}/backup/plans/:backupPlanId/selections/"]
                                                       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}}/backup/plans/:backupPlanId/selections/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup/plans/:backupPlanId/selections/",
  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}}/backup/plans/:backupPlanId/selections/');

echo $response->getBody();

setUrl('{{baseUrl}}/backup/plans/:backupPlanId/selections/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup/plans/:backupPlanId/selections/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup/plans/:backupPlanId/selections/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/plans/:backupPlanId/selections/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup/plans/:backupPlanId/selections/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup/plans/:backupPlanId/selections/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/plans/:backupPlanId/selections/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup/plans/:backupPlanId/selections/")

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/backup/plans/:backupPlanId/selections/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup/plans/:backupPlanId/selections/";

    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}}/backup/plans/:backupPlanId/selections/

http GET {{baseUrl}}/backup/plans/:backupPlanId/selections/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup/plans/:backupPlanId/selections/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup/plans/:backupPlanId/selections/")! 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 ListBackupVaults

{{baseUrl}}/backup-vaults/

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup-vaults/")

require "http/client"

url = "{{baseUrl}}/backup-vaults/"

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}}/backup-vaults/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup-vaults/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-vaults/"

	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/backup-vaults/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup-vaults/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/"))
    .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}}/backup-vaults/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup-vaults/")
  .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}}/backup-vaults/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/backup-vaults/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-vaults/';
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}}/backup-vaults/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup-vaults/',
  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}}/backup-vaults/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup-vaults/');

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}}/backup-vaults/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-vaults/';
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}}/backup-vaults/"]
                                                       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}}/backup-vaults/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-vaults/",
  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}}/backup-vaults/');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup-vaults/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup-vaults/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-vaults/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/")

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/backup-vaults/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/";

    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}}/backup-vaults/

http GET {{baseUrl}}/backup-vaults/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup-vaults/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/")! 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 ListCopyJobs

{{baseUrl}}/copy-jobs/

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/copy-jobs/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/copy-jobs/")

require "http/client"

url = "{{baseUrl}}/copy-jobs/"

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}}/copy-jobs/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/copy-jobs/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/copy-jobs/"

	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/copy-jobs/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/copy-jobs/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/copy-jobs/"))
    .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}}/copy-jobs/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/copy-jobs/")
  .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}}/copy-jobs/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/copy-jobs/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/copy-jobs/';
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}}/copy-jobs/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/copy-jobs/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/copy-jobs/',
  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}}/copy-jobs/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/copy-jobs/');

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}}/copy-jobs/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/copy-jobs/';
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}}/copy-jobs/"]
                                                       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}}/copy-jobs/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/copy-jobs/",
  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}}/copy-jobs/');

echo $response->getBody();

setUrl('{{baseUrl}}/copy-jobs/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/copy-jobs/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/copy-jobs/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/copy-jobs/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/copy-jobs/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/copy-jobs/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/copy-jobs/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/copy-jobs/")

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/copy-jobs/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/copy-jobs/";

    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}}/copy-jobs/

http GET {{baseUrl}}/copy-jobs/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/copy-jobs/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/copy-jobs/")! 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 ListFrameworks

{{baseUrl}}/audit/frameworks

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/frameworks");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/audit/frameworks")

require "http/client"

url = "{{baseUrl}}/audit/frameworks"

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}}/audit/frameworks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/audit/frameworks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/audit/frameworks"

	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/audit/frameworks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/audit/frameworks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/frameworks"))
    .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}}/audit/frameworks")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/audit/frameworks")
  .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}}/audit/frameworks');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/audit/frameworks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/audit/frameworks';
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}}/audit/frameworks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/audit/frameworks")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/audit/frameworks',
  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}}/audit/frameworks'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/audit/frameworks');

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}}/audit/frameworks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/audit/frameworks';
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}}/audit/frameworks"]
                                                       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}}/audit/frameworks" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/audit/frameworks",
  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}}/audit/frameworks');

echo $response->getBody();

setUrl('{{baseUrl}}/audit/frameworks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/audit/frameworks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/frameworks' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/frameworks' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/audit/frameworks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/audit/frameworks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/frameworks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/frameworks")

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/audit/frameworks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/frameworks";

    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}}/audit/frameworks

http GET {{baseUrl}}/audit/frameworks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/audit/frameworks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/frameworks")! 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 ListLegalHolds

{{baseUrl}}/legal-holds/

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/legal-holds/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/legal-holds/")

require "http/client"

url = "{{baseUrl}}/legal-holds/"

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}}/legal-holds/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/legal-holds/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/legal-holds/"

	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/legal-holds/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/legal-holds/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/legal-holds/"))
    .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}}/legal-holds/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/legal-holds/")
  .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}}/legal-holds/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/legal-holds/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/legal-holds/';
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}}/legal-holds/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/legal-holds/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/legal-holds/',
  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}}/legal-holds/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/legal-holds/');

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}}/legal-holds/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/legal-holds/';
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}}/legal-holds/"]
                                                       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}}/legal-holds/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/legal-holds/",
  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}}/legal-holds/');

echo $response->getBody();

setUrl('{{baseUrl}}/legal-holds/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/legal-holds/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/legal-holds/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/legal-holds/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/legal-holds/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/legal-holds/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/legal-holds/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/legal-holds/")

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/legal-holds/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/legal-holds/";

    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}}/legal-holds/

http GET {{baseUrl}}/legal-holds/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/legal-holds/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/legal-holds/")! 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 ListProtectedResources

{{baseUrl}}/resources/

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resources/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resources/")

require "http/client"

url = "{{baseUrl}}/resources/"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resources/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resources/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resources/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resources/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resources/")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resources/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/resources/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resources/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resources/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources/',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/resources/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resources/');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/resources/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resources/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resources/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resources/');

echo $response->getBody();

setUrl('{{baseUrl}}/resources/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resources/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/resources/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resources/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/resources/

http GET {{baseUrl}}/resources/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resources/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET ListRecoveryPointsByBackupVault

{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/

QUERY PARAMS

backupVaultName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/")

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/"

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}}/backup-vaults/:backupVaultName/recovery-points/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/"

	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/backup-vaults/:backupVaultName/recovery-points/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/"))
    .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}}/backup-vaults/:backupVaultName/recovery-points/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/")
  .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}}/backup-vaults/:backupVaultName/recovery-points/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/';
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}}/backup-vaults/:backupVaultName/recovery-points/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup-vaults/:backupVaultName/recovery-points/',
  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}}/backup-vaults/:backupVaultName/recovery-points/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/');

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}}/backup-vaults/:backupVaultName/recovery-points/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/';
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}}/backup-vaults/:backupVaultName/recovery-points/"]
                                                       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}}/backup-vaults/:backupVaultName/recovery-points/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/",
  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}}/backup-vaults/:backupVaultName/recovery-points/');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/backup-vaults/:backupVaultName/recovery-points/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/")

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/backup-vaults/:backupVaultName/recovery-points/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/";

    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}}/backup-vaults/:backupVaultName/recovery-points/

http GET {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/")! 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 ListRecoveryPointsByLegalHold

{{baseUrl}}/legal-holds/:legalHoldId/recovery-points

QUERY PARAMS

legalHoldId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/legal-holds/:legalHoldId/recovery-points");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/legal-holds/:legalHoldId/recovery-points")

require "http/client"

url = "{{baseUrl}}/legal-holds/:legalHoldId/recovery-points"

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}}/legal-holds/:legalHoldId/recovery-points"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/legal-holds/:legalHoldId/recovery-points");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/legal-holds/:legalHoldId/recovery-points"

	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/legal-holds/:legalHoldId/recovery-points HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/legal-holds/:legalHoldId/recovery-points")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/legal-holds/:legalHoldId/recovery-points"))
    .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}}/legal-holds/:legalHoldId/recovery-points")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/legal-holds/:legalHoldId/recovery-points")
  .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}}/legal-holds/:legalHoldId/recovery-points');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/legal-holds/:legalHoldId/recovery-points'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/legal-holds/:legalHoldId/recovery-points';
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}}/legal-holds/:legalHoldId/recovery-points',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/legal-holds/:legalHoldId/recovery-points")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/legal-holds/:legalHoldId/recovery-points',
  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}}/legal-holds/:legalHoldId/recovery-points'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/legal-holds/:legalHoldId/recovery-points');

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}}/legal-holds/:legalHoldId/recovery-points'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/legal-holds/:legalHoldId/recovery-points';
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}}/legal-holds/:legalHoldId/recovery-points"]
                                                       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}}/legal-holds/:legalHoldId/recovery-points" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/legal-holds/:legalHoldId/recovery-points",
  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}}/legal-holds/:legalHoldId/recovery-points');

echo $response->getBody();

setUrl('{{baseUrl}}/legal-holds/:legalHoldId/recovery-points');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/legal-holds/:legalHoldId/recovery-points');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/legal-holds/:legalHoldId/recovery-points' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/legal-holds/:legalHoldId/recovery-points' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/legal-holds/:legalHoldId/recovery-points")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/legal-holds/:legalHoldId/recovery-points"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/legal-holds/:legalHoldId/recovery-points"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/legal-holds/:legalHoldId/recovery-points")

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/legal-holds/:legalHoldId/recovery-points') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/legal-holds/:legalHoldId/recovery-points";

    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}}/legal-holds/:legalHoldId/recovery-points

http GET {{baseUrl}}/legal-holds/:legalHoldId/recovery-points

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/legal-holds/:legalHoldId/recovery-points

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/legal-holds/:legalHoldId/recovery-points")! 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 ListRecoveryPointsByResource

{{baseUrl}}/resources/:resourceArn/recovery-points/

QUERY PARAMS

resourceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resources/:resourceArn/recovery-points/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resources/:resourceArn/recovery-points/")

require "http/client"

url = "{{baseUrl}}/resources/:resourceArn/recovery-points/"

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}}/resources/:resourceArn/recovery-points/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resources/:resourceArn/recovery-points/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resources/:resourceArn/recovery-points/"

	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/resources/:resourceArn/recovery-points/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resources/:resourceArn/recovery-points/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resources/:resourceArn/recovery-points/"))
    .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}}/resources/:resourceArn/recovery-points/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resources/:resourceArn/recovery-points/")
  .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}}/resources/:resourceArn/recovery-points/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resources/:resourceArn/recovery-points/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resources/:resourceArn/recovery-points/';
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}}/resources/:resourceArn/recovery-points/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resources/:resourceArn/recovery-points/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resources/:resourceArn/recovery-points/',
  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}}/resources/:resourceArn/recovery-points/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resources/:resourceArn/recovery-points/');

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}}/resources/:resourceArn/recovery-points/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resources/:resourceArn/recovery-points/';
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}}/resources/:resourceArn/recovery-points/"]
                                                       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}}/resources/:resourceArn/recovery-points/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resources/:resourceArn/recovery-points/",
  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}}/resources/:resourceArn/recovery-points/');

echo $response->getBody();

setUrl('{{baseUrl}}/resources/:resourceArn/recovery-points/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resources/:resourceArn/recovery-points/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resources/:resourceArn/recovery-points/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resources/:resourceArn/recovery-points/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/resources/:resourceArn/recovery-points/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resources/:resourceArn/recovery-points/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resources/:resourceArn/recovery-points/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resources/:resourceArn/recovery-points/")

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/resources/:resourceArn/recovery-points/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resources/:resourceArn/recovery-points/";

    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}}/resources/:resourceArn/recovery-points/

http GET {{baseUrl}}/resources/:resourceArn/recovery-points/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resources/:resourceArn/recovery-points/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resources/:resourceArn/recovery-points/")! 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 ListReportJobs

{{baseUrl}}/audit/report-jobs

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/report-jobs");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/audit/report-jobs")

require "http/client"

url = "{{baseUrl}}/audit/report-jobs"

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}}/audit/report-jobs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/audit/report-jobs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/audit/report-jobs"

	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/audit/report-jobs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/audit/report-jobs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/report-jobs"))
    .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}}/audit/report-jobs")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/audit/report-jobs")
  .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}}/audit/report-jobs');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/audit/report-jobs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/audit/report-jobs';
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}}/audit/report-jobs',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/audit/report-jobs")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/audit/report-jobs',
  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}}/audit/report-jobs'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/audit/report-jobs');

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}}/audit/report-jobs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/audit/report-jobs';
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}}/audit/report-jobs"]
                                                       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}}/audit/report-jobs" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/audit/report-jobs",
  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}}/audit/report-jobs');

echo $response->getBody();

setUrl('{{baseUrl}}/audit/report-jobs');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/audit/report-jobs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/report-jobs' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/report-jobs' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/audit/report-jobs")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/audit/report-jobs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/report-jobs"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/report-jobs")

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/audit/report-jobs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/report-jobs";

    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}}/audit/report-jobs

http GET {{baseUrl}}/audit/report-jobs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/audit/report-jobs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/report-jobs")! 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 ListReportPlans

{{baseUrl}}/audit/report-plans

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/report-plans");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/audit/report-plans")

require "http/client"

url = "{{baseUrl}}/audit/report-plans"

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}}/audit/report-plans"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/audit/report-plans");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/audit/report-plans"

	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/audit/report-plans HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/audit/report-plans")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/report-plans"))
    .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}}/audit/report-plans")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/audit/report-plans")
  .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}}/audit/report-plans');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/audit/report-plans'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/audit/report-plans';
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}}/audit/report-plans',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/audit/report-plans")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/audit/report-plans',
  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}}/audit/report-plans'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/audit/report-plans');

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}}/audit/report-plans'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/audit/report-plans';
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}}/audit/report-plans"]
                                                       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}}/audit/report-plans" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/audit/report-plans",
  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}}/audit/report-plans');

echo $response->getBody();

setUrl('{{baseUrl}}/audit/report-plans');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/audit/report-plans');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/report-plans' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/report-plans' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/audit/report-plans")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/audit/report-plans"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/report-plans"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/report-plans")

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/audit/report-plans') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/report-plans";

    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}}/audit/report-plans

http GET {{baseUrl}}/audit/report-plans

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/audit/report-plans

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/report-plans")! 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 ListRestoreJobs

{{baseUrl}}/restore-jobs/

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restore-jobs/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/restore-jobs/")

require "http/client"

url = "{{baseUrl}}/restore-jobs/"

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}}/restore-jobs/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/restore-jobs/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restore-jobs/"

	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/restore-jobs/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/restore-jobs/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restore-jobs/"))
    .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}}/restore-jobs/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/restore-jobs/")
  .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}}/restore-jobs/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/restore-jobs/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restore-jobs/';
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}}/restore-jobs/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/restore-jobs/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/restore-jobs/',
  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}}/restore-jobs/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/restore-jobs/');

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}}/restore-jobs/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restore-jobs/';
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}}/restore-jobs/"]
                                                       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}}/restore-jobs/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restore-jobs/",
  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}}/restore-jobs/');

echo $response->getBody();

setUrl('{{baseUrl}}/restore-jobs/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/restore-jobs/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/restore-jobs/' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/restore-jobs/' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/restore-jobs/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restore-jobs/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restore-jobs/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/restore-jobs/")

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/restore-jobs/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/restore-jobs/";

    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}}/restore-jobs/

http GET {{baseUrl}}/restore-jobs/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/restore-jobs/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restore-jobs/")! 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()

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()

PUT PutBackupVaultAccessPolicy

{{baseUrl}}/backup-vaults/:backupVaultName/access-policy

QUERY PARAMS

backupVaultName

BODY json

{
  "Policy": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy");

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  \"Policy\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy" {:content-type :json
                                                                                        :form-params {:Policy ""}})

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Policy\": \"\"\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}}/backup-vaults/:backupVaultName/access-policy"),
    Content = new StringContent("{\n  \"Policy\": \"\"\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}}/backup-vaults/:backupVaultName/access-policy");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Policy\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"

	payload := strings.NewReader("{\n  \"Policy\": \"\"\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/backup-vaults/:backupVaultName/access-policy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 18

{
  "Policy": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Policy\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"Policy\": \"\"\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  \"Policy\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")
  .header("content-type", "application/json")
  .body("{\n  \"Policy\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Policy: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy',
  headers: {'content-type': 'application/json'},
  data: {Policy: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Policy":""}'
};

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}}/backup-vaults/:backupVaultName/access-policy',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Policy": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Policy\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")
  .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/backup-vaults/:backupVaultName/access-policy',
  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({Policy: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy',
  headers: {'content-type': 'application/json'},
  body: {Policy: ''},
  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}}/backup-vaults/:backupVaultName/access-policy');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Policy: ''
});

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}}/backup-vaults/:backupVaultName/access-policy',
  headers: {'content-type': 'application/json'},
  data: {Policy: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"Policy":""}'
};

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 = @{ @"Policy": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"]
                                                       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}}/backup-vaults/:backupVaultName/access-policy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Policy\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy",
  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([
    'Policy' => ''
  ]),
  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}}/backup-vaults/:backupVaultName/access-policy', [
  'body' => '{
  "Policy": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/access-policy');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Policy' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Policy' => ''
]));
$request->setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/access-policy');
$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}}/backup-vaults/:backupVaultName/access-policy' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Policy": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/access-policy' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "Policy": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Policy\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/backup-vaults/:backupVaultName/access-policy", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"

payload = { "Policy": "" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy"

payload <- "{\n  \"Policy\": \"\"\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}}/backup-vaults/:backupVaultName/access-policy")

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  \"Policy\": \"\"\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/backup-vaults/:backupVaultName/access-policy') do |req|
  req.body = "{\n  \"Policy\": \"\"\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}}/backup-vaults/:backupVaultName/access-policy";

    let payload = json!({"Policy": ""});

    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}}/backup-vaults/:backupVaultName/access-policy \
  --header 'content-type: application/json' \
  --data '{
  "Policy": ""
}'

echo '{
  "Policy": ""
}' |  \
  http PUT {{baseUrl}}/backup-vaults/:backupVaultName/access-policy \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "Policy": ""\n}' \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/access-policy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Policy": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/access-policy")! 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 PutBackupVaultLockConfiguration

{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock

QUERY PARAMS

backupVaultName

BODY json

{
  "MinRetentionDays": 0,
  "MaxRetentionDays": 0,
  "ChangeableForDays": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock");

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  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock" {:content-type :json
                                                                                     :form-params {:MinRetentionDays 0
                                                                                                   :MaxRetentionDays 0
                                                                                                   :ChangeableForDays 0}})

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock"),
    Content = new StringContent("{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock"

	payload := strings.NewReader("{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/backup-vaults/:backupVaultName/vault-lock HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 78

{
  "MinRetentionDays": 0,
  "MaxRetentionDays": 0,
  "ChangeableForDays": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")
  .header("content-type", "application/json")
  .body("{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}")
  .asString();

const data = JSON.stringify({
  MinRetentionDays: 0,
  MaxRetentionDays: 0,
  ChangeableForDays: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock',
  headers: {'content-type': 'application/json'},
  data: {MinRetentionDays: 0, MaxRetentionDays: 0, ChangeableForDays: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"MinRetentionDays":0,"MaxRetentionDays":0,"ChangeableForDays":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MinRetentionDays": 0,\n  "MaxRetentionDays": 0,\n  "ChangeableForDays": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")
  .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/backup-vaults/:backupVaultName/vault-lock',
  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({MinRetentionDays: 0, MaxRetentionDays: 0, ChangeableForDays: 0}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock',
  headers: {'content-type': 'application/json'},
  body: {MinRetentionDays: 0, MaxRetentionDays: 0, ChangeableForDays: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  MinRetentionDays: 0,
  MaxRetentionDays: 0,
  ChangeableForDays: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock',
  headers: {'content-type': 'application/json'},
  data: {MinRetentionDays: 0, MaxRetentionDays: 0, ChangeableForDays: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"MinRetentionDays":0,"MaxRetentionDays":0,"ChangeableForDays":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"MinRetentionDays": @0,
                              @"MaxRetentionDays": @0,
                              @"ChangeableForDays": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock"]
                                                       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}}/backup-vaults/:backupVaultName/vault-lock" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock",
  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([
    'MinRetentionDays' => 0,
    'MaxRetentionDays' => 0,
    'ChangeableForDays' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock', [
  'body' => '{
  "MinRetentionDays": 0,
  "MaxRetentionDays": 0,
  "ChangeableForDays": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MinRetentionDays' => 0,
  'MaxRetentionDays' => 0,
  'ChangeableForDays' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'MinRetentionDays' => 0,
  'MaxRetentionDays' => 0,
  'ChangeableForDays' => 0
]));
$request->setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock');
$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}}/backup-vaults/:backupVaultName/vault-lock' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "MinRetentionDays": 0,
  "MaxRetentionDays": 0,
  "ChangeableForDays": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "MinRetentionDays": 0,
  "MaxRetentionDays": 0,
  "ChangeableForDays": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/backup-vaults/:backupVaultName/vault-lock", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock"

payload = {
    "MinRetentionDays": 0,
    "MaxRetentionDays": 0,
    "ChangeableForDays": 0
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock"

payload <- "{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")

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  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/backup-vaults/:backupVaultName/vault-lock') do |req|
  req.body = "{\n  \"MinRetentionDays\": 0,\n  \"MaxRetentionDays\": 0,\n  \"ChangeableForDays\": 0\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock";

    let payload = json!({
        "MinRetentionDays": 0,
        "MaxRetentionDays": 0,
        "ChangeableForDays": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/backup-vaults/:backupVaultName/vault-lock \
  --header 'content-type: application/json' \
  --data '{
  "MinRetentionDays": 0,
  "MaxRetentionDays": 0,
  "ChangeableForDays": 0
}'

echo '{
  "MinRetentionDays": 0,
  "MaxRetentionDays": 0,
  "ChangeableForDays": 0
}' |  \
  http PUT {{baseUrl}}/backup-vaults/:backupVaultName/vault-lock \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "MinRetentionDays": 0,\n  "MaxRetentionDays": 0,\n  "ChangeableForDays": 0\n}' \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/vault-lock

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "MinRetentionDays": 0,
  "MaxRetentionDays": 0,
  "ChangeableForDays": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/vault-lock")! 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 PutBackupVaultNotifications

{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration

QUERY PARAMS

backupVaultName

BODY json

{
  "SNSTopicArn": "",
  "BackupVaultEvents": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration");

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  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration" {:content-type :json
                                                                                                     :form-params {:SNSTopicArn ""
                                                                                                                   :BackupVaultEvents []}})

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\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}}/backup-vaults/:backupVaultName/notification-configuration"),
    Content = new StringContent("{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\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}}/backup-vaults/:backupVaultName/notification-configuration");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"

	payload := strings.NewReader("{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\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/backup-vaults/:backupVaultName/notification-configuration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 50

{
  "SNSTopicArn": "",
  "BackupVaultEvents": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\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  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")
  .header("content-type", "application/json")
  .body("{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\n}")
  .asString();

const data = JSON.stringify({
  SNSTopicArn: '',
  BackupVaultEvents: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration',
  headers: {'content-type': 'application/json'},
  data: {SNSTopicArn: '', BackupVaultEvents: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"SNSTopicArn":"","BackupVaultEvents":[]}'
};

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}}/backup-vaults/:backupVaultName/notification-configuration',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SNSTopicArn": "",\n  "BackupVaultEvents": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")
  .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/backup-vaults/:backupVaultName/notification-configuration',
  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({SNSTopicArn: '', BackupVaultEvents: []}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration',
  headers: {'content-type': 'application/json'},
  body: {SNSTopicArn: '', BackupVaultEvents: []},
  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}}/backup-vaults/:backupVaultName/notification-configuration');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SNSTopicArn: '',
  BackupVaultEvents: []
});

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}}/backup-vaults/:backupVaultName/notification-configuration',
  headers: {'content-type': 'application/json'},
  data: {SNSTopicArn: '', BackupVaultEvents: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"SNSTopicArn":"","BackupVaultEvents":[]}'
};

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 = @{ @"SNSTopicArn": @"",
                              @"BackupVaultEvents": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"]
                                                       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}}/backup-vaults/:backupVaultName/notification-configuration" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration",
  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([
    'SNSTopicArn' => '',
    'BackupVaultEvents' => [
        
    ]
  ]),
  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}}/backup-vaults/:backupVaultName/notification-configuration', [
  'body' => '{
  "SNSTopicArn": "",
  "BackupVaultEvents": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SNSTopicArn' => '',
  'BackupVaultEvents' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SNSTopicArn' => '',
  'BackupVaultEvents' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration');
$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}}/backup-vaults/:backupVaultName/notification-configuration' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "SNSTopicArn": "",
  "BackupVaultEvents": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "SNSTopicArn": "",
  "BackupVaultEvents": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/backup-vaults/:backupVaultName/notification-configuration", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"

payload = {
    "SNSTopicArn": "",
    "BackupVaultEvents": []
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration"

payload <- "{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\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}}/backup-vaults/:backupVaultName/notification-configuration")

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  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\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/backup-vaults/:backupVaultName/notification-configuration') do |req|
  req.body = "{\n  \"SNSTopicArn\": \"\",\n  \"BackupVaultEvents\": []\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}}/backup-vaults/:backupVaultName/notification-configuration";

    let payload = json!({
        "SNSTopicArn": "",
        "BackupVaultEvents": ()
    });

    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}}/backup-vaults/:backupVaultName/notification-configuration \
  --header 'content-type: application/json' \
  --data '{
  "SNSTopicArn": "",
  "BackupVaultEvents": []
}'

echo '{
  "SNSTopicArn": "",
  "BackupVaultEvents": []
}' |  \
  http PUT {{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "SNSTopicArn": "",\n  "BackupVaultEvents": []\n}' \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "SNSTopicArn": "",
  "BackupVaultEvents": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/notification-configuration")! 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 StartBackupJob

{{baseUrl}}/backup-jobs

BODY json

{
  "BackupVaultName": "",
  "ResourceArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "StartWindowMinutes": 0,
  "CompleteWindowMinutes": 0,
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  },
  "RecoveryPointTags": {},
  "BackupOptions": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-jobs");

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  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/backup-jobs" {:content-type :json
                                                       :form-params {:BackupVaultName ""
                                                                     :ResourceArn ""
                                                                     :IamRoleArn ""
                                                                     :IdempotencyToken ""
                                                                     :StartWindowMinutes 0
                                                                     :CompleteWindowMinutes 0
                                                                     :Lifecycle {:MoveToColdStorageAfterDays ""
                                                                                 :DeleteAfterDays ""}
                                                                     :RecoveryPointTags {}
                                                                     :BackupOptions {}}})

require "http/client"

url = "{{baseUrl}}/backup-jobs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\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}}/backup-jobs"),
    Content = new StringContent("{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\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}}/backup-jobs");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-jobs"

	payload := strings.NewReader("{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\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/backup-jobs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 287

{
  "BackupVaultName": "",
  "ResourceArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "StartWindowMinutes": 0,
  "CompleteWindowMinutes": 0,
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  },
  "RecoveryPointTags": {},
  "BackupOptions": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/backup-jobs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-jobs"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\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  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/backup-jobs")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/backup-jobs")
  .header("content-type", "application/json")
  .body("{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\n}")
  .asString();

const data = JSON.stringify({
  BackupVaultName: '',
  ResourceArn: '',
  IamRoleArn: '',
  IdempotencyToken: '',
  StartWindowMinutes: 0,
  CompleteWindowMinutes: 0,
  Lifecycle: {
    MoveToColdStorageAfterDays: '',
    DeleteAfterDays: ''
  },
  RecoveryPointTags: {},
  BackupOptions: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/backup-jobs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup-jobs',
  headers: {'content-type': 'application/json'},
  data: {
    BackupVaultName: '',
    ResourceArn: '',
    IamRoleArn: '',
    IdempotencyToken: '',
    StartWindowMinutes: 0,
    CompleteWindowMinutes: 0,
    Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''},
    RecoveryPointTags: {},
    BackupOptions: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-jobs';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"BackupVaultName":"","ResourceArn":"","IamRoleArn":"","IdempotencyToken":"","StartWindowMinutes":0,"CompleteWindowMinutes":0,"Lifecycle":{"MoveToColdStorageAfterDays":"","DeleteAfterDays":""},"RecoveryPointTags":{},"BackupOptions":{}}'
};

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}}/backup-jobs',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BackupVaultName": "",\n  "ResourceArn": "",\n  "IamRoleArn": "",\n  "IdempotencyToken": "",\n  "StartWindowMinutes": 0,\n  "CompleteWindowMinutes": 0,\n  "Lifecycle": {\n    "MoveToColdStorageAfterDays": "",\n    "DeleteAfterDays": ""\n  },\n  "RecoveryPointTags": {},\n  "BackupOptions": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/backup-jobs")
  .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/backup-jobs',
  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({
  BackupVaultName: '',
  ResourceArn: '',
  IamRoleArn: '',
  IdempotencyToken: '',
  StartWindowMinutes: 0,
  CompleteWindowMinutes: 0,
  Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''},
  RecoveryPointTags: {},
  BackupOptions: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/backup-jobs',
  headers: {'content-type': 'application/json'},
  body: {
    BackupVaultName: '',
    ResourceArn: '',
    IamRoleArn: '',
    IdempotencyToken: '',
    StartWindowMinutes: 0,
    CompleteWindowMinutes: 0,
    Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''},
    RecoveryPointTags: {},
    BackupOptions: {}
  },
  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}}/backup-jobs');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  BackupVaultName: '',
  ResourceArn: '',
  IamRoleArn: '',
  IdempotencyToken: '',
  StartWindowMinutes: 0,
  CompleteWindowMinutes: 0,
  Lifecycle: {
    MoveToColdStorageAfterDays: '',
    DeleteAfterDays: ''
  },
  RecoveryPointTags: {},
  BackupOptions: {}
});

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}}/backup-jobs',
  headers: {'content-type': 'application/json'},
  data: {
    BackupVaultName: '',
    ResourceArn: '',
    IamRoleArn: '',
    IdempotencyToken: '',
    StartWindowMinutes: 0,
    CompleteWindowMinutes: 0,
    Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''},
    RecoveryPointTags: {},
    BackupOptions: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-jobs';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"BackupVaultName":"","ResourceArn":"","IamRoleArn":"","IdempotencyToken":"","StartWindowMinutes":0,"CompleteWindowMinutes":0,"Lifecycle":{"MoveToColdStorageAfterDays":"","DeleteAfterDays":""},"RecoveryPointTags":{},"BackupOptions":{}}'
};

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 = @{ @"BackupVaultName": @"",
                              @"ResourceArn": @"",
                              @"IamRoleArn": @"",
                              @"IdempotencyToken": @"",
                              @"StartWindowMinutes": @0,
                              @"CompleteWindowMinutes": @0,
                              @"Lifecycle": @{ @"MoveToColdStorageAfterDays": @"", @"DeleteAfterDays": @"" },
                              @"RecoveryPointTags": @{  },
                              @"BackupOptions": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backup-jobs"]
                                                       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}}/backup-jobs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-jobs",
  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([
    'BackupVaultName' => '',
    'ResourceArn' => '',
    'IamRoleArn' => '',
    'IdempotencyToken' => '',
    'StartWindowMinutes' => 0,
    'CompleteWindowMinutes' => 0,
    'Lifecycle' => [
        'MoveToColdStorageAfterDays' => '',
        'DeleteAfterDays' => ''
    ],
    'RecoveryPointTags' => [
        
    ],
    'BackupOptions' => [
        
    ]
  ]),
  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}}/backup-jobs', [
  'body' => '{
  "BackupVaultName": "",
  "ResourceArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "StartWindowMinutes": 0,
  "CompleteWindowMinutes": 0,
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  },
  "RecoveryPointTags": {},
  "BackupOptions": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/backup-jobs');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BackupVaultName' => '',
  'ResourceArn' => '',
  'IamRoleArn' => '',
  'IdempotencyToken' => '',
  'StartWindowMinutes' => 0,
  'CompleteWindowMinutes' => 0,
  'Lifecycle' => [
    'MoveToColdStorageAfterDays' => '',
    'DeleteAfterDays' => ''
  ],
  'RecoveryPointTags' => [
    
  ],
  'BackupOptions' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'BackupVaultName' => '',
  'ResourceArn' => '',
  'IamRoleArn' => '',
  'IdempotencyToken' => '',
  'StartWindowMinutes' => 0,
  'CompleteWindowMinutes' => 0,
  'Lifecycle' => [
    'MoveToColdStorageAfterDays' => '',
    'DeleteAfterDays' => ''
  ],
  'RecoveryPointTags' => [
    
  ],
  'BackupOptions' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/backup-jobs');
$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}}/backup-jobs' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "BackupVaultName": "",
  "ResourceArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "StartWindowMinutes": 0,
  "CompleteWindowMinutes": 0,
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  },
  "RecoveryPointTags": {},
  "BackupOptions": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-jobs' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "BackupVaultName": "",
  "ResourceArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "StartWindowMinutes": 0,
  "CompleteWindowMinutes": 0,
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  },
  "RecoveryPointTags": {},
  "BackupOptions": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/backup-jobs", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-jobs"

payload = {
    "BackupVaultName": "",
    "ResourceArn": "",
    "IamRoleArn": "",
    "IdempotencyToken": "",
    "StartWindowMinutes": 0,
    "CompleteWindowMinutes": 0,
    "Lifecycle": {
        "MoveToColdStorageAfterDays": "",
        "DeleteAfterDays": ""
    },
    "RecoveryPointTags": {},
    "BackupOptions": {}
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-jobs"

payload <- "{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\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}}/backup-jobs")

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  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\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/backup-jobs') do |req|
  req.body = "{\n  \"BackupVaultName\": \"\",\n  \"ResourceArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"StartWindowMinutes\": 0,\n  \"CompleteWindowMinutes\": 0,\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  },\n  \"RecoveryPointTags\": {},\n  \"BackupOptions\": {}\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}}/backup-jobs";

    let payload = json!({
        "BackupVaultName": "",
        "ResourceArn": "",
        "IamRoleArn": "",
        "IdempotencyToken": "",
        "StartWindowMinutes": 0,
        "CompleteWindowMinutes": 0,
        "Lifecycle": json!({
            "MoveToColdStorageAfterDays": "",
            "DeleteAfterDays": ""
        }),
        "RecoveryPointTags": json!({}),
        "BackupOptions": json!({})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/backup-jobs \
  --header 'content-type: application/json' \
  --data '{
  "BackupVaultName": "",
  "ResourceArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "StartWindowMinutes": 0,
  "CompleteWindowMinutes": 0,
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  },
  "RecoveryPointTags": {},
  "BackupOptions": {}
}'

echo '{
  "BackupVaultName": "",
  "ResourceArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "StartWindowMinutes": 0,
  "CompleteWindowMinutes": 0,
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  },
  "RecoveryPointTags": {},
  "BackupOptions": {}
}' |  \
  http PUT {{baseUrl}}/backup-jobs \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "BackupVaultName": "",\n  "ResourceArn": "",\n  "IamRoleArn": "",\n  "IdempotencyToken": "",\n  "StartWindowMinutes": 0,\n  "CompleteWindowMinutes": 0,\n  "Lifecycle": {\n    "MoveToColdStorageAfterDays": "",\n    "DeleteAfterDays": ""\n  },\n  "RecoveryPointTags": {},\n  "BackupOptions": {}\n}' \
  --output-document \
  - {{baseUrl}}/backup-jobs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "BackupVaultName": "",
  "ResourceArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "StartWindowMinutes": 0,
  "CompleteWindowMinutes": 0,
  "Lifecycle": [
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  ],
  "RecoveryPointTags": [],
  "BackupOptions": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-jobs")! 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 StartCopyJob

{{baseUrl}}/copy-jobs

BODY json

{
  "RecoveryPointArn": "",
  "SourceBackupVaultName": "",
  "DestinationBackupVaultArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/copy-jobs");

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  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/copy-jobs" {:content-type :json
                                                     :form-params {:RecoveryPointArn ""
                                                                   :SourceBackupVaultName ""
                                                                   :DestinationBackupVaultArn ""
                                                                   :IamRoleArn ""
                                                                   :IdempotencyToken ""
                                                                   :Lifecycle {:MoveToColdStorageAfterDays ""
                                                                               :DeleteAfterDays ""}}})

require "http/client"

url = "{{baseUrl}}/copy-jobs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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}}/copy-jobs"),
    Content = new StringContent("{\n  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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}}/copy-jobs");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/copy-jobs"

	payload := strings.NewReader("{\n  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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/copy-jobs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 226

{
  "RecoveryPointArn": "",
  "SourceBackupVaultName": "",
  "DestinationBackupVaultArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/copy-jobs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/copy-jobs"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/copy-jobs")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/copy-jobs")
  .header("content-type", "application/json")
  .body("{\n  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  RecoveryPointArn: '',
  SourceBackupVaultName: '',
  DestinationBackupVaultArn: '',
  IamRoleArn: '',
  IdempotencyToken: '',
  Lifecycle: {
    MoveToColdStorageAfterDays: '',
    DeleteAfterDays: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/copy-jobs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/copy-jobs',
  headers: {'content-type': 'application/json'},
  data: {
    RecoveryPointArn: '',
    SourceBackupVaultName: '',
    DestinationBackupVaultArn: '',
    IamRoleArn: '',
    IdempotencyToken: '',
    Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/copy-jobs';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"RecoveryPointArn":"","SourceBackupVaultName":"","DestinationBackupVaultArn":"","IamRoleArn":"","IdempotencyToken":"","Lifecycle":{"MoveToColdStorageAfterDays":"","DeleteAfterDays":""}}'
};

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}}/copy-jobs',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "RecoveryPointArn": "",\n  "SourceBackupVaultName": "",\n  "DestinationBackupVaultArn": "",\n  "IamRoleArn": "",\n  "IdempotencyToken": "",\n  "Lifecycle": {\n    "MoveToColdStorageAfterDays": "",\n    "DeleteAfterDays": ""\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  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/copy-jobs")
  .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/copy-jobs',
  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({
  RecoveryPointArn: '',
  SourceBackupVaultName: '',
  DestinationBackupVaultArn: '',
  IamRoleArn: '',
  IdempotencyToken: '',
  Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/copy-jobs',
  headers: {'content-type': 'application/json'},
  body: {
    RecoveryPointArn: '',
    SourceBackupVaultName: '',
    DestinationBackupVaultArn: '',
    IamRoleArn: '',
    IdempotencyToken: '',
    Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''}
  },
  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}}/copy-jobs');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  RecoveryPointArn: '',
  SourceBackupVaultName: '',
  DestinationBackupVaultArn: '',
  IamRoleArn: '',
  IdempotencyToken: '',
  Lifecycle: {
    MoveToColdStorageAfterDays: '',
    DeleteAfterDays: ''
  }
});

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}}/copy-jobs',
  headers: {'content-type': 'application/json'},
  data: {
    RecoveryPointArn: '',
    SourceBackupVaultName: '',
    DestinationBackupVaultArn: '',
    IamRoleArn: '',
    IdempotencyToken: '',
    Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/copy-jobs';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"RecoveryPointArn":"","SourceBackupVaultName":"","DestinationBackupVaultArn":"","IamRoleArn":"","IdempotencyToken":"","Lifecycle":{"MoveToColdStorageAfterDays":"","DeleteAfterDays":""}}'
};

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 = @{ @"RecoveryPointArn": @"",
                              @"SourceBackupVaultName": @"",
                              @"DestinationBackupVaultArn": @"",
                              @"IamRoleArn": @"",
                              @"IdempotencyToken": @"",
                              @"Lifecycle": @{ @"MoveToColdStorageAfterDays": @"", @"DeleteAfterDays": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/copy-jobs"]
                                                       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}}/copy-jobs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/copy-jobs",
  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([
    'RecoveryPointArn' => '',
    'SourceBackupVaultName' => '',
    'DestinationBackupVaultArn' => '',
    'IamRoleArn' => '',
    'IdempotencyToken' => '',
    'Lifecycle' => [
        'MoveToColdStorageAfterDays' => '',
        'DeleteAfterDays' => ''
    ]
  ]),
  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}}/copy-jobs', [
  'body' => '{
  "RecoveryPointArn": "",
  "SourceBackupVaultName": "",
  "DestinationBackupVaultArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/copy-jobs');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'RecoveryPointArn' => '',
  'SourceBackupVaultName' => '',
  'DestinationBackupVaultArn' => '',
  'IamRoleArn' => '',
  'IdempotencyToken' => '',
  'Lifecycle' => [
    'MoveToColdStorageAfterDays' => '',
    'DeleteAfterDays' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'RecoveryPointArn' => '',
  'SourceBackupVaultName' => '',
  'DestinationBackupVaultArn' => '',
  'IamRoleArn' => '',
  'IdempotencyToken' => '',
  'Lifecycle' => [
    'MoveToColdStorageAfterDays' => '',
    'DeleteAfterDays' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/copy-jobs');
$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}}/copy-jobs' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "RecoveryPointArn": "",
  "SourceBackupVaultName": "",
  "DestinationBackupVaultArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/copy-jobs' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "RecoveryPointArn": "",
  "SourceBackupVaultName": "",
  "DestinationBackupVaultArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/copy-jobs", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/copy-jobs"

payload = {
    "RecoveryPointArn": "",
    "SourceBackupVaultName": "",
    "DestinationBackupVaultArn": "",
    "IamRoleArn": "",
    "IdempotencyToken": "",
    "Lifecycle": {
        "MoveToColdStorageAfterDays": "",
        "DeleteAfterDays": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/copy-jobs"

payload <- "{\n  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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}}/copy-jobs")

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  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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/copy-jobs') do |req|
  req.body = "{\n  \"RecoveryPointArn\": \"\",\n  \"SourceBackupVaultName\": \"\",\n  \"DestinationBackupVaultArn\": \"\",\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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}}/copy-jobs";

    let payload = json!({
        "RecoveryPointArn": "",
        "SourceBackupVaultName": "",
        "DestinationBackupVaultArn": "",
        "IamRoleArn": "",
        "IdempotencyToken": "",
        "Lifecycle": json!({
            "MoveToColdStorageAfterDays": "",
            "DeleteAfterDays": ""
        })
    });

    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}}/copy-jobs \
  --header 'content-type: application/json' \
  --data '{
  "RecoveryPointArn": "",
  "SourceBackupVaultName": "",
  "DestinationBackupVaultArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}'

echo '{
  "RecoveryPointArn": "",
  "SourceBackupVaultName": "",
  "DestinationBackupVaultArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}' |  \
  http PUT {{baseUrl}}/copy-jobs \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "RecoveryPointArn": "",\n  "SourceBackupVaultName": "",\n  "DestinationBackupVaultArn": "",\n  "IamRoleArn": "",\n  "IdempotencyToken": "",\n  "Lifecycle": {\n    "MoveToColdStorageAfterDays": "",\n    "DeleteAfterDays": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/copy-jobs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "RecoveryPointArn": "",
  "SourceBackupVaultName": "",
  "DestinationBackupVaultArn": "",
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "Lifecycle": [
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/copy-jobs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StartReportJob

{{baseUrl}}/audit/report-jobs/:reportPlanName

QUERY PARAMS

reportPlanName

BODY json

{
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/report-jobs/:reportPlanName");

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  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/audit/report-jobs/:reportPlanName" {:content-type :json
                                                                              :form-params {:IdempotencyToken ""}})

require "http/client"

url = "{{baseUrl}}/audit/report-jobs/:reportPlanName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"IdempotencyToken\": \"\"\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}}/audit/report-jobs/:reportPlanName"),
    Content = new StringContent("{\n  \"IdempotencyToken\": \"\"\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}}/audit/report-jobs/:reportPlanName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"IdempotencyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/audit/report-jobs/:reportPlanName"

	payload := strings.NewReader("{\n  \"IdempotencyToken\": \"\"\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/audit/report-jobs/:reportPlanName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/audit/report-jobs/:reportPlanName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/report-jobs/:reportPlanName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"IdempotencyToken\": \"\"\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  \"IdempotencyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/audit/report-jobs/:reportPlanName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/audit/report-jobs/:reportPlanName")
  .header("content-type", "application/json")
  .body("{\n  \"IdempotencyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  IdempotencyToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/audit/report-jobs/:reportPlanName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/report-jobs/:reportPlanName',
  headers: {'content-type': 'application/json'},
  data: {IdempotencyToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/audit/report-jobs/:reportPlanName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"IdempotencyToken":""}'
};

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}}/audit/report-jobs/:reportPlanName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "IdempotencyToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/audit/report-jobs/:reportPlanName")
  .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/audit/report-jobs/:reportPlanName',
  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({IdempotencyToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/report-jobs/:reportPlanName',
  headers: {'content-type': 'application/json'},
  body: {IdempotencyToken: ''},
  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}}/audit/report-jobs/:reportPlanName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  IdempotencyToken: ''
});

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}}/audit/report-jobs/:reportPlanName',
  headers: {'content-type': 'application/json'},
  data: {IdempotencyToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/audit/report-jobs/:reportPlanName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"IdempotencyToken":""}'
};

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 = @{ @"IdempotencyToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/audit/report-jobs/:reportPlanName"]
                                                       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}}/audit/report-jobs/:reportPlanName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"IdempotencyToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/audit/report-jobs/:reportPlanName",
  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([
    'IdempotencyToken' => ''
  ]),
  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}}/audit/report-jobs/:reportPlanName', [
  'body' => '{
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/audit/report-jobs/:reportPlanName');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'IdempotencyToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/audit/report-jobs/:reportPlanName');
$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}}/audit/report-jobs/:reportPlanName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/report-jobs/:reportPlanName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "IdempotencyToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"IdempotencyToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/audit/report-jobs/:reportPlanName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/audit/report-jobs/:reportPlanName"

payload = { "IdempotencyToken": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/report-jobs/:reportPlanName"

payload <- "{\n  \"IdempotencyToken\": \"\"\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}}/audit/report-jobs/:reportPlanName")

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  \"IdempotencyToken\": \"\"\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/audit/report-jobs/:reportPlanName') do |req|
  req.body = "{\n  \"IdempotencyToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/report-jobs/:reportPlanName";

    let payload = json!({"IdempotencyToken": ""});

    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}}/audit/report-jobs/:reportPlanName \
  --header 'content-type: application/json' \
  --data '{
  "IdempotencyToken": ""
}'

echo '{
  "IdempotencyToken": ""
}' |  \
  http POST {{baseUrl}}/audit/report-jobs/:reportPlanName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/audit/report-jobs/:reportPlanName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["IdempotencyToken": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/report-jobs/:reportPlanName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT StartRestoreJob

{{baseUrl}}/restore-jobs

BODY json

{
  "RecoveryPointArn": "",
  "Metadata": {},
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "ResourceType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/restore-jobs");

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  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/restore-jobs" {:content-type :json
                                                        :form-params {:RecoveryPointArn ""
                                                                      :Metadata {}
                                                                      :IamRoleArn ""
                                                                      :IdempotencyToken ""
                                                                      :ResourceType ""}})

require "http/client"

url = "{{baseUrl}}/restore-jobs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\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}}/restore-jobs"),
    Content = new StringContent("{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\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}}/restore-jobs");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/restore-jobs"

	payload := strings.NewReader("{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\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/restore-jobs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 114

{
  "RecoveryPointArn": "",
  "Metadata": {},
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "ResourceType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/restore-jobs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/restore-jobs"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\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  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/restore-jobs")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/restore-jobs")
  .header("content-type", "application/json")
  .body("{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  RecoveryPointArn: '',
  Metadata: {},
  IamRoleArn: '',
  IdempotencyToken: '',
  ResourceType: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/restore-jobs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restore-jobs',
  headers: {'content-type': 'application/json'},
  data: {
    RecoveryPointArn: '',
    Metadata: {},
    IamRoleArn: '',
    IdempotencyToken: '',
    ResourceType: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/restore-jobs';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"RecoveryPointArn":"","Metadata":{},"IamRoleArn":"","IdempotencyToken":"","ResourceType":""}'
};

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}}/restore-jobs',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "RecoveryPointArn": "",\n  "Metadata": {},\n  "IamRoleArn": "",\n  "IdempotencyToken": "",\n  "ResourceType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/restore-jobs")
  .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/restore-jobs',
  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({
  RecoveryPointArn: '',
  Metadata: {},
  IamRoleArn: '',
  IdempotencyToken: '',
  ResourceType: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/restore-jobs',
  headers: {'content-type': 'application/json'},
  body: {
    RecoveryPointArn: '',
    Metadata: {},
    IamRoleArn: '',
    IdempotencyToken: '',
    ResourceType: ''
  },
  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}}/restore-jobs');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  RecoveryPointArn: '',
  Metadata: {},
  IamRoleArn: '',
  IdempotencyToken: '',
  ResourceType: ''
});

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}}/restore-jobs',
  headers: {'content-type': 'application/json'},
  data: {
    RecoveryPointArn: '',
    Metadata: {},
    IamRoleArn: '',
    IdempotencyToken: '',
    ResourceType: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/restore-jobs';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"RecoveryPointArn":"","Metadata":{},"IamRoleArn":"","IdempotencyToken":"","ResourceType":""}'
};

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 = @{ @"RecoveryPointArn": @"",
                              @"Metadata": @{  },
                              @"IamRoleArn": @"",
                              @"IdempotencyToken": @"",
                              @"ResourceType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/restore-jobs"]
                                                       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}}/restore-jobs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/restore-jobs",
  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([
    'RecoveryPointArn' => '',
    'Metadata' => [
        
    ],
    'IamRoleArn' => '',
    'IdempotencyToken' => '',
    'ResourceType' => ''
  ]),
  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}}/restore-jobs', [
  'body' => '{
  "RecoveryPointArn": "",
  "Metadata": {},
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "ResourceType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/restore-jobs');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'RecoveryPointArn' => '',
  'Metadata' => [
    
  ],
  'IamRoleArn' => '',
  'IdempotencyToken' => '',
  'ResourceType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'RecoveryPointArn' => '',
  'Metadata' => [
    
  ],
  'IamRoleArn' => '',
  'IdempotencyToken' => '',
  'ResourceType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/restore-jobs');
$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}}/restore-jobs' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "RecoveryPointArn": "",
  "Metadata": {},
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "ResourceType": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/restore-jobs' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "RecoveryPointArn": "",
  "Metadata": {},
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "ResourceType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/restore-jobs", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/restore-jobs"

payload = {
    "RecoveryPointArn": "",
    "Metadata": {},
    "IamRoleArn": "",
    "IdempotencyToken": "",
    "ResourceType": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/restore-jobs"

payload <- "{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\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}}/restore-jobs")

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  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\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/restore-jobs') do |req|
  req.body = "{\n  \"RecoveryPointArn\": \"\",\n  \"Metadata\": {},\n  \"IamRoleArn\": \"\",\n  \"IdempotencyToken\": \"\",\n  \"ResourceType\": \"\"\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}}/restore-jobs";

    let payload = json!({
        "RecoveryPointArn": "",
        "Metadata": json!({}),
        "IamRoleArn": "",
        "IdempotencyToken": "",
        "ResourceType": ""
    });

    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}}/restore-jobs \
  --header 'content-type: application/json' \
  --data '{
  "RecoveryPointArn": "",
  "Metadata": {},
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "ResourceType": ""
}'

echo '{
  "RecoveryPointArn": "",
  "Metadata": {},
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "ResourceType": ""
}' |  \
  http PUT {{baseUrl}}/restore-jobs \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "RecoveryPointArn": "",\n  "Metadata": {},\n  "IamRoleArn": "",\n  "IdempotencyToken": "",\n  "ResourceType": ""\n}' \
  --output-document \
  - {{baseUrl}}/restore-jobs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "RecoveryPointArn": "",
  "Metadata": [],
  "IamRoleArn": "",
  "IdempotencyToken": "",
  "ResourceType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/restore-jobs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST StopBackupJob

{{baseUrl}}/backup-jobs/:backupJobId

QUERY PARAMS

backupJobId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-jobs/:backupJobId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/backup-jobs/:backupJobId")

require "http/client"

url = "{{baseUrl}}/backup-jobs/:backupJobId"

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}}/backup-jobs/:backupJobId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/backup-jobs/:backupJobId");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-jobs/:backupJobId"

	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/backup-jobs/:backupJobId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backup-jobs/:backupJobId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-jobs/:backupJobId"))
    .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}}/backup-jobs/:backupJobId")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/backup-jobs/:backupJobId")
  .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}}/backup-jobs/:backupJobId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/backup-jobs/:backupJobId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-jobs/:backupJobId';
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}}/backup-jobs/:backupJobId',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/backup-jobs/:backupJobId")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/backup-jobs/:backupJobId',
  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}}/backup-jobs/:backupJobId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/backup-jobs/:backupJobId');

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}}/backup-jobs/:backupJobId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-jobs/:backupJobId';
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}}/backup-jobs/:backupJobId"]
                                                       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}}/backup-jobs/:backupJobId" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-jobs/:backupJobId",
  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}}/backup-jobs/:backupJobId');

echo $response->getBody();

setUrl('{{baseUrl}}/backup-jobs/:backupJobId');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/backup-jobs/:backupJobId');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/backup-jobs/:backupJobId' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-jobs/:backupJobId' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/backup-jobs/:backupJobId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-jobs/:backupJobId"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-jobs/:backupJobId"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/backup-jobs/:backupJobId")

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/backup-jobs/:backupJobId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-jobs/:backupJobId";

    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}}/backup-jobs/:backupJobId

http POST {{baseUrl}}/backup-jobs/:backupJobId

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/backup-jobs/:backupJobId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-jobs/:backupJobId")! 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()

POST UntagResource

{{baseUrl}}/untag/:resourceArn

QUERY PARAMS

resourceArn

BODY json

{
  "TagKeyList": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/untag/: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  \"TagKeyList\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/untag/:resourceArn" {:content-type :json
                                                               :form-params {:TagKeyList []}})

require "http/client"

url = "{{baseUrl}}/untag/:resourceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"TagKeyList\": []\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}}/untag/:resourceArn"),
    Content = new StringContent("{\n  \"TagKeyList\": []\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}}/untag/:resourceArn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TagKeyList\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/untag/:resourceArn"

	payload := strings.NewReader("{\n  \"TagKeyList\": []\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/untag/:resourceArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "TagKeyList": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/untag/:resourceArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TagKeyList\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/untag/:resourceArn"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TagKeyList\": []\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  \"TagKeyList\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/untag/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/untag/:resourceArn")
  .header("content-type", "application/json")
  .body("{\n  \"TagKeyList\": []\n}")
  .asString();

const data = JSON.stringify({
  TagKeyList: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/untag/:resourceArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/untag/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {TagKeyList: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/untag/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"TagKeyList":[]}'
};

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}}/untag/:resourceArn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TagKeyList": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TagKeyList\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/untag/: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/untag/: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({TagKeyList: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/untag/:resourceArn',
  headers: {'content-type': 'application/json'},
  body: {TagKeyList: []},
  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}}/untag/:resourceArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TagKeyList: []
});

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}}/untag/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {TagKeyList: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/untag/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"TagKeyList":[]}'
};

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 = @{ @"TagKeyList": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/untag/: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}}/untag/:resourceArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"TagKeyList\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/untag/: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([
    'TagKeyList' => [
        
    ]
  ]),
  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}}/untag/:resourceArn', [
  'body' => '{
  "TagKeyList": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/untag/:resourceArn');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TagKeyList' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TagKeyList' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/untag/: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}}/untag/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TagKeyList": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/untag/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TagKeyList": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TagKeyList\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/untag/:resourceArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/untag/:resourceArn"

payload = { "TagKeyList": [] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/untag/:resourceArn"

payload <- "{\n  \"TagKeyList\": []\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}}/untag/: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  \"TagKeyList\": []\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/untag/:resourceArn') do |req|
  req.body = "{\n  \"TagKeyList\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/untag/:resourceArn";

    let payload = json!({"TagKeyList": ()});

    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}}/untag/:resourceArn \
  --header 'content-type: application/json' \
  --data '{
  "TagKeyList": []
}'

echo '{
  "TagKeyList": []
}' |  \
  http POST {{baseUrl}}/untag/:resourceArn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "TagKeyList": []\n}' \
  --output-document \
  - {{baseUrl}}/untag/:resourceArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["TagKeyList": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/untag/: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()

POST UpdateBackupPlan

{{baseUrl}}/backup/plans/:backupPlanId

QUERY PARAMS

backupPlanId

BODY json

{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup/plans/:backupPlanId");

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  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/backup/plans/:backupPlanId" {:content-type :json
                                                                       :form-params {:BackupPlan {:BackupPlanName ""
                                                                                                  :Rules ""
                                                                                                  :AdvancedBackupSettings ""}}})

require "http/client"

url = "{{baseUrl}}/backup/plans/:backupPlanId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\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}}/backup/plans/:backupPlanId"),
    Content = new StringContent("{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\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}}/backup/plans/:backupPlanId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup/plans/:backupPlanId"

	payload := strings.NewReader("{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\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/backup/plans/:backupPlanId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 101

{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backup/plans/:backupPlanId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup/plans/:backupPlanId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\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  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/backup/plans/:backupPlanId")
  .header("content-type", "application/json")
  .body("{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  BackupPlan: {
    BackupPlanName: '',
    Rules: '',
    AdvancedBackupSettings: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/backup/plans/:backupPlanId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/backup/plans/:backupPlanId',
  headers: {'content-type': 'application/json'},
  data: {BackupPlan: {BackupPlanName: '', Rules: '', AdvancedBackupSettings: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup/plans/:backupPlanId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"BackupPlan":{"BackupPlanName":"","Rules":"","AdvancedBackupSettings":""}}'
};

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}}/backup/plans/:backupPlanId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BackupPlan": {\n    "BackupPlanName": "",\n    "Rules": "",\n    "AdvancedBackupSettings": ""\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  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/backup/plans/:backupPlanId")
  .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/backup/plans/:backupPlanId',
  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({BackupPlan: {BackupPlanName: '', Rules: '', AdvancedBackupSettings: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/backup/plans/:backupPlanId',
  headers: {'content-type': 'application/json'},
  body: {BackupPlan: {BackupPlanName: '', Rules: '', AdvancedBackupSettings: ''}},
  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}}/backup/plans/:backupPlanId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  BackupPlan: {
    BackupPlanName: '',
    Rules: '',
    AdvancedBackupSettings: ''
  }
});

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}}/backup/plans/:backupPlanId',
  headers: {'content-type': 'application/json'},
  data: {BackupPlan: {BackupPlanName: '', Rules: '', AdvancedBackupSettings: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup/plans/:backupPlanId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"BackupPlan":{"BackupPlanName":"","Rules":"","AdvancedBackupSettings":""}}'
};

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 = @{ @"BackupPlan": @{ @"BackupPlanName": @"", @"Rules": @"", @"AdvancedBackupSettings": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backup/plans/:backupPlanId"]
                                                       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}}/backup/plans/:backupPlanId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup/plans/:backupPlanId",
  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([
    'BackupPlan' => [
        'BackupPlanName' => '',
        'Rules' => '',
        'AdvancedBackupSettings' => ''
    ]
  ]),
  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}}/backup/plans/:backupPlanId', [
  'body' => '{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/backup/plans/:backupPlanId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BackupPlan' => [
    'BackupPlanName' => '',
    'Rules' => '',
    'AdvancedBackupSettings' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'BackupPlan' => [
    'BackupPlanName' => '',
    'Rules' => '',
    'AdvancedBackupSettings' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/backup/plans/:backupPlanId');
$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}}/backup/plans/:backupPlanId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup/plans/:backupPlanId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/backup/plans/:backupPlanId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup/plans/:backupPlanId"

payload = { "BackupPlan": {
        "BackupPlanName": "",
        "Rules": "",
        "AdvancedBackupSettings": ""
    } }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup/plans/:backupPlanId"

payload <- "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\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}}/backup/plans/:backupPlanId")

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  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\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/backup/plans/:backupPlanId') do |req|
  req.body = "{\n  \"BackupPlan\": {\n    \"BackupPlanName\": \"\",\n    \"Rules\": \"\",\n    \"AdvancedBackupSettings\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup/plans/:backupPlanId";

    let payload = json!({"BackupPlan": json!({
            "BackupPlanName": "",
            "Rules": "",
            "AdvancedBackupSettings": ""
        })});

    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}}/backup/plans/:backupPlanId \
  --header 'content-type: application/json' \
  --data '{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  }
}'

echo '{
  "BackupPlan": {
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  }
}' |  \
  http POST {{baseUrl}}/backup/plans/:backupPlanId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "BackupPlan": {\n    "BackupPlanName": "",\n    "Rules": "",\n    "AdvancedBackupSettings": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/backup/plans/:backupPlanId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["BackupPlan": [
    "BackupPlanName": "",
    "Rules": "",
    "AdvancedBackupSettings": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup/plans/:backupPlanId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT UpdateFramework

{{baseUrl}}/audit/frameworks/:frameworkName

QUERY PARAMS

frameworkName

BODY json

{
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/frameworks/:frameworkName");

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  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/audit/frameworks/:frameworkName" {:content-type :json
                                                                           :form-params {:FrameworkDescription ""
                                                                                         :FrameworkControls [{:ControlName ""
                                                                                                              :ControlInputParameters ""
                                                                                                              :ControlScope ""}]
                                                                                         :IdempotencyToken ""}})

require "http/client"

url = "{{baseUrl}}/audit/frameworks/:frameworkName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\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}}/audit/frameworks/:frameworkName"),
    Content = new StringContent("{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\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}}/audit/frameworks/:frameworkName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/audit/frameworks/:frameworkName"

	payload := strings.NewReader("{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\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/audit/frameworks/:frameworkName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 186

{
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/audit/frameworks/:frameworkName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/frameworks/:frameworkName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\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  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/audit/frameworks/:frameworkName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/audit/frameworks/:frameworkName")
  .header("content-type", "application/json")
  .body("{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FrameworkDescription: '',
  FrameworkControls: [
    {
      ControlName: '',
      ControlInputParameters: '',
      ControlScope: ''
    }
  ],
  IdempotencyToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/audit/frameworks/:frameworkName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/audit/frameworks/:frameworkName',
  headers: {'content-type': 'application/json'},
  data: {
    FrameworkDescription: '',
    FrameworkControls: [{ControlName: '', ControlInputParameters: '', ControlScope: ''}],
    IdempotencyToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/audit/frameworks/:frameworkName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"FrameworkDescription":"","FrameworkControls":[{"ControlName":"","ControlInputParameters":"","ControlScope":""}],"IdempotencyToken":""}'
};

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}}/audit/frameworks/:frameworkName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FrameworkDescription": "",\n  "FrameworkControls": [\n    {\n      "ControlName": "",\n      "ControlInputParameters": "",\n      "ControlScope": ""\n    }\n  ],\n  "IdempotencyToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/audit/frameworks/:frameworkName")
  .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/audit/frameworks/:frameworkName',
  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({
  FrameworkDescription: '',
  FrameworkControls: [{ControlName: '', ControlInputParameters: '', ControlScope: ''}],
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/audit/frameworks/:frameworkName',
  headers: {'content-type': 'application/json'},
  body: {
    FrameworkDescription: '',
    FrameworkControls: [{ControlName: '', ControlInputParameters: '', ControlScope: ''}],
    IdempotencyToken: ''
  },
  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}}/audit/frameworks/:frameworkName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FrameworkDescription: '',
  FrameworkControls: [
    {
      ControlName: '',
      ControlInputParameters: '',
      ControlScope: ''
    }
  ],
  IdempotencyToken: ''
});

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}}/audit/frameworks/:frameworkName',
  headers: {'content-type': 'application/json'},
  data: {
    FrameworkDescription: '',
    FrameworkControls: [{ControlName: '', ControlInputParameters: '', ControlScope: ''}],
    IdempotencyToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/audit/frameworks/:frameworkName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"FrameworkDescription":"","FrameworkControls":[{"ControlName":"","ControlInputParameters":"","ControlScope":""}],"IdempotencyToken":""}'
};

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 = @{ @"FrameworkDescription": @"",
                              @"FrameworkControls": @[ @{ @"ControlName": @"", @"ControlInputParameters": @"", @"ControlScope": @"" } ],
                              @"IdempotencyToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/audit/frameworks/:frameworkName"]
                                                       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}}/audit/frameworks/:frameworkName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/audit/frameworks/:frameworkName",
  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([
    'FrameworkDescription' => '',
    'FrameworkControls' => [
        [
                'ControlName' => '',
                'ControlInputParameters' => '',
                'ControlScope' => ''
        ]
    ],
    'IdempotencyToken' => ''
  ]),
  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}}/audit/frameworks/:frameworkName', [
  'body' => '{
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/audit/frameworks/:frameworkName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FrameworkDescription' => '',
  'FrameworkControls' => [
    [
        'ControlName' => '',
        'ControlInputParameters' => '',
        'ControlScope' => ''
    ]
  ],
  'IdempotencyToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FrameworkDescription' => '',
  'FrameworkControls' => [
    [
        'ControlName' => '',
        'ControlInputParameters' => '',
        'ControlScope' => ''
    ]
  ],
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/audit/frameworks/:frameworkName');
$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}}/audit/frameworks/:frameworkName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/frameworks/:frameworkName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/audit/frameworks/:frameworkName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/audit/frameworks/:frameworkName"

payload = {
    "FrameworkDescription": "",
    "FrameworkControls": [
        {
            "ControlName": "",
            "ControlInputParameters": "",
            "ControlScope": ""
        }
    ],
    "IdempotencyToken": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/frameworks/:frameworkName"

payload <- "{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\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}}/audit/frameworks/:frameworkName")

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  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\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/audit/frameworks/:frameworkName') do |req|
  req.body = "{\n  \"FrameworkDescription\": \"\",\n  \"FrameworkControls\": [\n    {\n      \"ControlName\": \"\",\n      \"ControlInputParameters\": \"\",\n      \"ControlScope\": \"\"\n    }\n  ],\n  \"IdempotencyToken\": \"\"\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}}/audit/frameworks/:frameworkName";

    let payload = json!({
        "FrameworkDescription": "",
        "FrameworkControls": (
            json!({
                "ControlName": "",
                "ControlInputParameters": "",
                "ControlScope": ""
            })
        ),
        "IdempotencyToken": ""
    });

    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}}/audit/frameworks/:frameworkName \
  --header 'content-type: application/json' \
  --data '{
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": ""
}'

echo '{
  "FrameworkDescription": "",
  "FrameworkControls": [
    {
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    }
  ],
  "IdempotencyToken": ""
}' |  \
  http PUT {{baseUrl}}/audit/frameworks/:frameworkName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "FrameworkDescription": "",\n  "FrameworkControls": [\n    {\n      "ControlName": "",\n      "ControlInputParameters": "",\n      "ControlScope": ""\n    }\n  ],\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/audit/frameworks/:frameworkName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "FrameworkDescription": "",
  "FrameworkControls": [
    [
      "ControlName": "",
      "ControlInputParameters": "",
      "ControlScope": ""
    ]
  ],
  "IdempotencyToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/frameworks/:frameworkName")! 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 UpdateGlobalSettings

{{baseUrl}}/global-settings

BODY json

{
  "GlobalSettings": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/global-settings");

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  \"GlobalSettings\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/global-settings" {:content-type :json
                                                           :form-params {:GlobalSettings {}}})

require "http/client"

url = "{{baseUrl}}/global-settings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"GlobalSettings\": {}\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}}/global-settings"),
    Content = new StringContent("{\n  \"GlobalSettings\": {}\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}}/global-settings");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GlobalSettings\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-settings"

	payload := strings.NewReader("{\n  \"GlobalSettings\": {}\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/global-settings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 26

{
  "GlobalSettings": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/global-settings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GlobalSettings\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-settings"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"GlobalSettings\": {}\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  \"GlobalSettings\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/global-settings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/global-settings")
  .header("content-type", "application/json")
  .body("{\n  \"GlobalSettings\": {}\n}")
  .asString();

const data = JSON.stringify({
  GlobalSettings: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/global-settings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/global-settings',
  headers: {'content-type': 'application/json'},
  data: {GlobalSettings: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GlobalSettings":{}}'
};

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}}/global-settings',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GlobalSettings": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GlobalSettings\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/global-settings")
  .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/global-settings',
  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({GlobalSettings: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/global-settings',
  headers: {'content-type': 'application/json'},
  body: {GlobalSettings: {}},
  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}}/global-settings');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GlobalSettings: {}
});

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}}/global-settings',
  headers: {'content-type': 'application/json'},
  data: {GlobalSettings: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"GlobalSettings":{}}'
};

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 = @{ @"GlobalSettings": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/global-settings"]
                                                       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}}/global-settings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"GlobalSettings\": {}\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-settings",
  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([
    'GlobalSettings' => [
        
    ]
  ]),
  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}}/global-settings', [
  'body' => '{
  "GlobalSettings": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/global-settings');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GlobalSettings' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GlobalSettings' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/global-settings');
$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}}/global-settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GlobalSettings": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "GlobalSettings": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GlobalSettings\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/global-settings", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-settings"

payload = { "GlobalSettings": {} }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-settings"

payload <- "{\n  \"GlobalSettings\": {}\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}}/global-settings")

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  \"GlobalSettings\": {}\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/global-settings') do |req|
  req.body = "{\n  \"GlobalSettings\": {}\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}}/global-settings";

    let payload = json!({"GlobalSettings": json!({})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/global-settings \
  --header 'content-type: application/json' \
  --data '{
  "GlobalSettings": {}
}'

echo '{
  "GlobalSettings": {}
}' |  \
  http PUT {{baseUrl}}/global-settings \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "GlobalSettings": {}\n}' \
  --output-document \
  - {{baseUrl}}/global-settings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["GlobalSettings": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-settings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateRecoveryPointLifecycle

{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn

QUERY PARAMS

backupVaultName

recoveryPointArn

BODY json

{
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn");

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  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn" {:content-type :json
                                                                                                             :form-params {:Lifecycle {:MoveToColdStorageAfterDays ""
                                                                                                                                       :DeleteAfterDays ""}}})

require "http/client"

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"),
    Content = new StringContent("{\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"

	payload := strings.NewReader("{\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 88

{
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .header("content-type", "application/json")
  .body("{\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Lifecycle: {
    MoveToColdStorageAfterDays: '',
    DeleteAfterDays: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn',
  headers: {'content-type': 'application/json'},
  data: {Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Lifecycle":{"MoveToColdStorageAfterDays":"","DeleteAfterDays":""}}'
};

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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Lifecycle": {\n    "MoveToColdStorageAfterDays": "",\n    "DeleteAfterDays": ""\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  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")
  .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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn',
  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({Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn',
  headers: {'content-type': 'application/json'},
  body: {Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''}},
  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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Lifecycle: {
    MoveToColdStorageAfterDays: '',
    DeleteAfterDays: ''
  }
});

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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn',
  headers: {'content-type': 'application/json'},
  data: {Lifecycle: {MoveToColdStorageAfterDays: '', DeleteAfterDays: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Lifecycle":{"MoveToColdStorageAfterDays":"","DeleteAfterDays":""}}'
};

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 = @{ @"Lifecycle": @{ @"MoveToColdStorageAfterDays": @"", @"DeleteAfterDays": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"]
                                                       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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn",
  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([
    'Lifecycle' => [
        'MoveToColdStorageAfterDays' => '',
        'DeleteAfterDays' => ''
    ]
  ]),
  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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn', [
  'body' => '{
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Lifecycle' => [
    'MoveToColdStorageAfterDays' => '',
    'DeleteAfterDays' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Lifecycle' => [
    'MoveToColdStorageAfterDays' => '',
    'DeleteAfterDays' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn');
$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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"

payload = { "Lifecycle": {
        "MoveToColdStorageAfterDays": "",
        "DeleteAfterDays": ""
    } }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn"

payload <- "{\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")

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  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\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/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn') do |req|
  req.body = "{\n  \"Lifecycle\": {\n    \"MoveToColdStorageAfterDays\": \"\",\n    \"DeleteAfterDays\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn";

    let payload = json!({"Lifecycle": json!({
            "MoveToColdStorageAfterDays": "",
            "DeleteAfterDays": ""
        })});

    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}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn \
  --header 'content-type: application/json' \
  --data '{
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}'

echo '{
  "Lifecycle": {
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  }
}' |  \
  http POST {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Lifecycle": {\n    "MoveToColdStorageAfterDays": "",\n    "DeleteAfterDays": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Lifecycle": [
    "MoveToColdStorageAfterDays": "",
    "DeleteAfterDays": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/backup-vaults/:backupVaultName/recovery-points/:recoveryPointArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT UpdateRegionSettings

{{baseUrl}}/account-settings

BODY json

{
  "ResourceTypeOptInPreference": {},
  "ResourceTypeManagementPreference": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/account-settings");

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  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/account-settings" {:content-type :json
                                                            :form-params {:ResourceTypeOptInPreference {}
                                                                          :ResourceTypeManagementPreference {}}})

require "http/client"

url = "{{baseUrl}}/account-settings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\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}}/account-settings"),
    Content = new StringContent("{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/account-settings");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/account-settings"

	payload := strings.NewReader("{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\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/account-settings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 81

{
  "ResourceTypeOptInPreference": {},
  "ResourceTypeManagementPreference": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/account-settings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/account-settings"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\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  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/account-settings")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/account-settings")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\n}")
  .asString();

const data = JSON.stringify({
  ResourceTypeOptInPreference: {},
  ResourceTypeManagementPreference: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/account-settings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account-settings',
  headers: {'content-type': 'application/json'},
  data: {ResourceTypeOptInPreference: {}, ResourceTypeManagementPreference: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/account-settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ResourceTypeOptInPreference":{},"ResourceTypeManagementPreference":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/account-settings',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceTypeOptInPreference": {},\n  "ResourceTypeManagementPreference": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/account-settings")
  .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/account-settings',
  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({ResourceTypeOptInPreference: {}, ResourceTypeManagementPreference: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/account-settings',
  headers: {'content-type': 'application/json'},
  body: {ResourceTypeOptInPreference: {}, ResourceTypeManagementPreference: {}},
  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}}/account-settings');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceTypeOptInPreference: {},
  ResourceTypeManagementPreference: {}
});

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}}/account-settings',
  headers: {'content-type': 'application/json'},
  data: {ResourceTypeOptInPreference: {}, ResourceTypeManagementPreference: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/account-settings';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ResourceTypeOptInPreference":{},"ResourceTypeManagementPreference":{}}'
};

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 = @{ @"ResourceTypeOptInPreference": @{  },
                              @"ResourceTypeManagementPreference": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/account-settings"]
                                                       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}}/account-settings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/account-settings",
  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([
    'ResourceTypeOptInPreference' => [
        
    ],
    'ResourceTypeManagementPreference' => [
        
    ]
  ]),
  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}}/account-settings', [
  'body' => '{
  "ResourceTypeOptInPreference": {},
  "ResourceTypeManagementPreference": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/account-settings');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceTypeOptInPreference' => [
    
  ],
  'ResourceTypeManagementPreference' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceTypeOptInPreference' => [
    
  ],
  'ResourceTypeManagementPreference' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/account-settings');
$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}}/account-settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceTypeOptInPreference": {},
  "ResourceTypeManagementPreference": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/account-settings' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceTypeOptInPreference": {},
  "ResourceTypeManagementPreference": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/account-settings", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/account-settings"

payload = {
    "ResourceTypeOptInPreference": {},
    "ResourceTypeManagementPreference": {}
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/account-settings"

payload <- "{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\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}}/account-settings")

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  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\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/account-settings') do |req|
  req.body = "{\n  \"ResourceTypeOptInPreference\": {},\n  \"ResourceTypeManagementPreference\": {}\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/account-settings";

    let payload = json!({
        "ResourceTypeOptInPreference": json!({}),
        "ResourceTypeManagementPreference": json!({})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/account-settings \
  --header 'content-type: application/json' \
  --data '{
  "ResourceTypeOptInPreference": {},
  "ResourceTypeManagementPreference": {}
}'

echo '{
  "ResourceTypeOptInPreference": {},
  "ResourceTypeManagementPreference": {}
}' |  \
  http PUT {{baseUrl}}/account-settings \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceTypeOptInPreference": {},\n  "ResourceTypeManagementPreference": {}\n}' \
  --output-document \
  - {{baseUrl}}/account-settings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ResourceTypeOptInPreference": [],
  "ResourceTypeManagementPreference": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/account-settings")! 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 UpdateReportPlan

{{baseUrl}}/audit/report-plans/:reportPlanName

QUERY PARAMS

reportPlanName

BODY json

{
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "IdempotencyToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/report-plans/:reportPlanName");

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  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/audit/report-plans/:reportPlanName" {:content-type :json
                                                                              :form-params {:ReportPlanDescription ""
                                                                                            :ReportDeliveryChannel {:S3BucketName ""
                                                                                                                    :S3KeyPrefix ""
                                                                                                                    :Formats ""}
                                                                                            :ReportSetting {:ReportTemplate ""
                                                                                                            :FrameworkArns ""
                                                                                                            :NumberOfFrameworks ""
                                                                                                            :Accounts ""
                                                                                                            :OrganizationUnits ""
                                                                                                            :Regions ""}
                                                                                            :IdempotencyToken ""}})

require "http/client"

url = "{{baseUrl}}/audit/report-plans/:reportPlanName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\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}}/audit/report-plans/:reportPlanName"),
    Content = new StringContent("{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\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}}/audit/report-plans/:reportPlanName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/audit/report-plans/:reportPlanName"

	payload := strings.NewReader("{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\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/audit/report-plans/:reportPlanName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 332

{
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "IdempotencyToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/audit/report-plans/:reportPlanName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/report-plans/:reportPlanName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\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  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/audit/report-plans/:reportPlanName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/audit/report-plans/:reportPlanName")
  .header("content-type", "application/json")
  .body("{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ReportPlanDescription: '',
  ReportDeliveryChannel: {
    S3BucketName: '',
    S3KeyPrefix: '',
    Formats: ''
  },
  ReportSetting: {
    ReportTemplate: '',
    FrameworkArns: '',
    NumberOfFrameworks: '',
    Accounts: '',
    OrganizationUnits: '',
    Regions: ''
  },
  IdempotencyToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/audit/report-plans/:reportPlanName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/audit/report-plans/:reportPlanName',
  headers: {'content-type': 'application/json'},
  data: {
    ReportPlanDescription: '',
    ReportDeliveryChannel: {S3BucketName: '', S3KeyPrefix: '', Formats: ''},
    ReportSetting: {
      ReportTemplate: '',
      FrameworkArns: '',
      NumberOfFrameworks: '',
      Accounts: '',
      OrganizationUnits: '',
      Regions: ''
    },
    IdempotencyToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/audit/report-plans/:reportPlanName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ReportPlanDescription":"","ReportDeliveryChannel":{"S3BucketName":"","S3KeyPrefix":"","Formats":""},"ReportSetting":{"ReportTemplate":"","FrameworkArns":"","NumberOfFrameworks":"","Accounts":"","OrganizationUnits":"","Regions":""},"IdempotencyToken":""}'
};

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}}/audit/report-plans/:reportPlanName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ReportPlanDescription": "",\n  "ReportDeliveryChannel": {\n    "S3BucketName": "",\n    "S3KeyPrefix": "",\n    "Formats": ""\n  },\n  "ReportSetting": {\n    "ReportTemplate": "",\n    "FrameworkArns": "",\n    "NumberOfFrameworks": "",\n    "Accounts": "",\n    "OrganizationUnits": "",\n    "Regions": ""\n  },\n  "IdempotencyToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/audit/report-plans/:reportPlanName")
  .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/audit/report-plans/:reportPlanName',
  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({
  ReportPlanDescription: '',
  ReportDeliveryChannel: {S3BucketName: '', S3KeyPrefix: '', Formats: ''},
  ReportSetting: {
    ReportTemplate: '',
    FrameworkArns: '',
    NumberOfFrameworks: '',
    Accounts: '',
    OrganizationUnits: '',
    Regions: ''
  },
  IdempotencyToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/audit/report-plans/:reportPlanName',
  headers: {'content-type': 'application/json'},
  body: {
    ReportPlanDescription: '',
    ReportDeliveryChannel: {S3BucketName: '', S3KeyPrefix: '', Formats: ''},
    ReportSetting: {
      ReportTemplate: '',
      FrameworkArns: '',
      NumberOfFrameworks: '',
      Accounts: '',
      OrganizationUnits: '',
      Regions: ''
    },
    IdempotencyToken: ''
  },
  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}}/audit/report-plans/:reportPlanName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ReportPlanDescription: '',
  ReportDeliveryChannel: {
    S3BucketName: '',
    S3KeyPrefix: '',
    Formats: ''
  },
  ReportSetting: {
    ReportTemplate: '',
    FrameworkArns: '',
    NumberOfFrameworks: '',
    Accounts: '',
    OrganizationUnits: '',
    Regions: ''
  },
  IdempotencyToken: ''
});

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}}/audit/report-plans/:reportPlanName',
  headers: {'content-type': 'application/json'},
  data: {
    ReportPlanDescription: '',
    ReportDeliveryChannel: {S3BucketName: '', S3KeyPrefix: '', Formats: ''},
    ReportSetting: {
      ReportTemplate: '',
      FrameworkArns: '',
      NumberOfFrameworks: '',
      Accounts: '',
      OrganizationUnits: '',
      Regions: ''
    },
    IdempotencyToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/audit/report-plans/:reportPlanName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ReportPlanDescription":"","ReportDeliveryChannel":{"S3BucketName":"","S3KeyPrefix":"","Formats":""},"ReportSetting":{"ReportTemplate":"","FrameworkArns":"","NumberOfFrameworks":"","Accounts":"","OrganizationUnits":"","Regions":""},"IdempotencyToken":""}'
};

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 = @{ @"ReportPlanDescription": @"",
                              @"ReportDeliveryChannel": @{ @"S3BucketName": @"", @"S3KeyPrefix": @"", @"Formats": @"" },
                              @"ReportSetting": @{ @"ReportTemplate": @"", @"FrameworkArns": @"", @"NumberOfFrameworks": @"", @"Accounts": @"", @"OrganizationUnits": @"", @"Regions": @"" },
                              @"IdempotencyToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/audit/report-plans/:reportPlanName"]
                                                       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}}/audit/report-plans/:reportPlanName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/audit/report-plans/:reportPlanName",
  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([
    'ReportPlanDescription' => '',
    'ReportDeliveryChannel' => [
        'S3BucketName' => '',
        'S3KeyPrefix' => '',
        'Formats' => ''
    ],
    'ReportSetting' => [
        'ReportTemplate' => '',
        'FrameworkArns' => '',
        'NumberOfFrameworks' => '',
        'Accounts' => '',
        'OrganizationUnits' => '',
        'Regions' => ''
    ],
    'IdempotencyToken' => ''
  ]),
  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}}/audit/report-plans/:reportPlanName', [
  'body' => '{
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "IdempotencyToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/audit/report-plans/:reportPlanName');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReportPlanDescription' => '',
  'ReportDeliveryChannel' => [
    'S3BucketName' => '',
    'S3KeyPrefix' => '',
    'Formats' => ''
  ],
  'ReportSetting' => [
    'ReportTemplate' => '',
    'FrameworkArns' => '',
    'NumberOfFrameworks' => '',
    'Accounts' => '',
    'OrganizationUnits' => '',
    'Regions' => ''
  ],
  'IdempotencyToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ReportPlanDescription' => '',
  'ReportDeliveryChannel' => [
    'S3BucketName' => '',
    'S3KeyPrefix' => '',
    'Formats' => ''
  ],
  'ReportSetting' => [
    'ReportTemplate' => '',
    'FrameworkArns' => '',
    'NumberOfFrameworks' => '',
    'Accounts' => '',
    'OrganizationUnits' => '',
    'Regions' => ''
  ],
  'IdempotencyToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/audit/report-plans/:reportPlanName');
$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}}/audit/report-plans/:reportPlanName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "IdempotencyToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/report-plans/:reportPlanName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "IdempotencyToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/audit/report-plans/:reportPlanName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/audit/report-plans/:reportPlanName"

payload = {
    "ReportPlanDescription": "",
    "ReportDeliveryChannel": {
        "S3BucketName": "",
        "S3KeyPrefix": "",
        "Formats": ""
    },
    "ReportSetting": {
        "ReportTemplate": "",
        "FrameworkArns": "",
        "NumberOfFrameworks": "",
        "Accounts": "",
        "OrganizationUnits": "",
        "Regions": ""
    },
    "IdempotencyToken": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/report-plans/:reportPlanName"

payload <- "{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\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}}/audit/report-plans/:reportPlanName")

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  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\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/audit/report-plans/:reportPlanName') do |req|
  req.body = "{\n  \"ReportPlanDescription\": \"\",\n  \"ReportDeliveryChannel\": {\n    \"S3BucketName\": \"\",\n    \"S3KeyPrefix\": \"\",\n    \"Formats\": \"\"\n  },\n  \"ReportSetting\": {\n    \"ReportTemplate\": \"\",\n    \"FrameworkArns\": \"\",\n    \"NumberOfFrameworks\": \"\",\n    \"Accounts\": \"\",\n    \"OrganizationUnits\": \"\",\n    \"Regions\": \"\"\n  },\n  \"IdempotencyToken\": \"\"\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}}/audit/report-plans/:reportPlanName";

    let payload = json!({
        "ReportPlanDescription": "",
        "ReportDeliveryChannel": json!({
            "S3BucketName": "",
            "S3KeyPrefix": "",
            "Formats": ""
        }),
        "ReportSetting": json!({
            "ReportTemplate": "",
            "FrameworkArns": "",
            "NumberOfFrameworks": "",
            "Accounts": "",
            "OrganizationUnits": "",
            "Regions": ""
        }),
        "IdempotencyToken": ""
    });

    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}}/audit/report-plans/:reportPlanName \
  --header 'content-type: application/json' \
  --data '{
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "IdempotencyToken": ""
}'

echo '{
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": {
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  },
  "ReportSetting": {
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  },
  "IdempotencyToken": ""
}' |  \
  http PUT {{baseUrl}}/audit/report-plans/:reportPlanName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReportPlanDescription": "",\n  "ReportDeliveryChannel": {\n    "S3BucketName": "",\n    "S3KeyPrefix": "",\n    "Formats": ""\n  },\n  "ReportSetting": {\n    "ReportTemplate": "",\n    "FrameworkArns": "",\n    "NumberOfFrameworks": "",\n    "Accounts": "",\n    "OrganizationUnits": "",\n    "Regions": ""\n  },\n  "IdempotencyToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/audit/report-plans/:reportPlanName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ReportPlanDescription": "",
  "ReportDeliveryChannel": [
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "Formats": ""
  ],
  "ReportSetting": [
    "ReportTemplate": "",
    "FrameworkArns": "",
    "NumberOfFrameworks": "",
    "Accounts": "",
    "OrganizationUnits": "",
    "Regions": ""
  ],
  "IdempotencyToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/report-plans/:reportPlanName")! 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()