POST Create Federated Instance
{{baseUrl}}/vapi/federation/instance
BODY json
{
  "instance_name": "",
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": false
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/federation/instance");

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  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/federation/instance" {:content-type :json
                                                                     :form-params {:instance_name ""
                                                                                   :url_address ""
                                                                                   :username ""
                                                                                   :password ""
                                                                                   :enabled false}})
require "http/client"

url = "{{baseUrl}}/vapi/federation/instance"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/vapi/federation/instance"),
    Content = new StringContent("{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/federation/instance");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/federation/instance"

	payload := strings.NewReader("{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}")

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

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

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

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

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

}
POST /baseUrl/vapi/federation/instance HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 102

{
  "instance_name": "",
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": false
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/federation/instance")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/federation/instance"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/federation/instance")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/federation/instance")
  .header("content-type", "application/json")
  .body("{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}")
  .asString();
const data = JSON.stringify({
  instance_name: '',
  url_address: '',
  username: '',
  password: '',
  enabled: false
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/federation/instance',
  headers: {'content-type': 'application/json'},
  data: {instance_name: '', url_address: '', username: '', password: '', enabled: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/federation/instance';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"instance_name":"","url_address":"","username":"","password":"","enabled":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/federation/instance',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "instance_name": "",\n  "url_address": "",\n  "username": "",\n  "password": "",\n  "enabled": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/federation/instance")
  .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/vapi/federation/instance',
  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({instance_name: '', url_address: '', username: '', password: '', enabled: false}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/federation/instance',
  headers: {'content-type': 'application/json'},
  body: {instance_name: '', url_address: '', username: '', password: '', enabled: false},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/vapi/federation/instance');

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

req.type('json');
req.send({
  instance_name: '',
  url_address: '',
  username: '',
  password: '',
  enabled: false
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/federation/instance',
  headers: {'content-type': 'application/json'},
  data: {instance_name: '', url_address: '', username: '', password: '', enabled: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/federation/instance';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"instance_name":"","url_address":"","username":"","password":"","enabled":false}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"instance_name": @"",
                              @"url_address": @"",
                              @"username": @"",
                              @"password": @"",
                              @"enabled": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/federation/instance"]
                                                       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}}/vapi/federation/instance" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/federation/instance",
  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([
    'instance_name' => '',
    'url_address' => '',
    'username' => '',
    'password' => '',
    'enabled' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/vapi/federation/instance', [
  'body' => '{
  "instance_name": "",
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/federation/instance');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'instance_name' => '',
  'url_address' => '',
  'username' => '',
  'password' => '',
  'enabled' => null
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'instance_name' => '',
  'url_address' => '',
  'username' => '',
  'password' => '',
  'enabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/vapi/federation/instance');
$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}}/vapi/federation/instance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "instance_name": "",
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": false
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/federation/instance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "instance_name": "",
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": false
}'
import http.client

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

payload = "{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}"

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

conn.request("POST", "/baseUrl/vapi/federation/instance", payload, headers)

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

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

url = "{{baseUrl}}/vapi/federation/instance"

payload = {
    "instance_name": "",
    "url_address": "",
    "username": "",
    "password": "",
    "enabled": False
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/federation/instance"

payload <- "{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/federation/instance")

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  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/vapi/federation/instance') do |req|
  req.body = "{\n  \"instance_name\": \"\",\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": false\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "instance_name": "",
        "url_address": "",
        "username": "",
        "password": "",
        "enabled": false
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/vapi/federation/instance \
  --header 'content-type: application/json' \
  --data '{
  "instance_name": "",
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": false
}'
echo '{
  "instance_name": "",
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": false
}' |  \
  http POST {{baseUrl}}/vapi/federation/instance \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "instance_name": "",\n  "url_address": "",\n  "username": "",\n  "password": "",\n  "enabled": false\n}' \
  --output-document \
  - {{baseUrl}}/vapi/federation/instance
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "instance_name": "",
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/federation/instance")! 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 Delete Federated Instance
{{baseUrl}}/vapi/federation/instance
QUERY PARAMS
instance_name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/federation/instance?instance_name=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/vapi/federation/instance" {:query-params {:instance_name ""}})
require "http/client"

url = "{{baseUrl}}/vapi/federation/instance?instance_name="

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/vapi/federation/instance?instance_name="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/federation/instance?instance_name=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/federation/instance?instance_name="

	req, _ := http.NewRequest("DELETE", url, nil)

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

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

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

}
DELETE /baseUrl/vapi/federation/instance?instance_name= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/vapi/federation/instance?instance_name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/federation/instance?instance_name="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/federation/instance?instance_name=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/vapi/federation/instance?instance_name=")
  .asString();
const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/vapi/federation/instance?instance_name=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/federation/instance',
  params: {instance_name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/federation/instance?instance_name=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/federation/instance?instance_name=',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/federation/instance?instance_name=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/federation/instance?instance_name=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/federation/instance',
  qs: {instance_name: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/vapi/federation/instance');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/federation/instance',
  params: {instance_name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/federation/instance?instance_name=';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/federation/instance?instance_name="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/federation/instance?instance_name=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/federation/instance?instance_name=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/vapi/federation/instance?instance_name=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/federation/instance');
$request->setMethod(HTTP_METH_DELETE);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/federation/instance');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'instance_name' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/federation/instance?instance_name=' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/federation/instance?instance_name=' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/vapi/federation/instance?instance_name=")

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

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

url = "{{baseUrl}}/vapi/federation/instance"

querystring = {"instance_name":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/federation/instance"

queryString <- list(instance_name = "")

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/federation/instance?instance_name=")

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

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/vapi/federation/instance') do |req|
  req.params['instance_name'] = ''
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

    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}}/vapi/federation/instance?instance_name='
http DELETE '{{baseUrl}}/vapi/federation/instance?instance_name='
wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/vapi/federation/instance?instance_name='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/federation/instance?instance_name=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()
GET Get Instance Info
{{baseUrl}}/vapi/federation/instance_info
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/federation/instance_info");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/federation/instance_info")
require "http/client"

url = "{{baseUrl}}/vapi/federation/instance_info"

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}}/vapi/federation/instance_info"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/federation/instance_info");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/federation/instance_info"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/federation/instance_info")
  .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}}/vapi/federation/instance_info');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/federation/instance_info'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/federation/instance_info';
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}}/vapi/federation/instance_info',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/federation/instance_info');

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}}/vapi/federation/instance_info'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/federation/instance_info",
  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}}/vapi/federation/instance_info');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/federation/instance_info');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/federation/instance_info');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/federation/instance_info' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/federation/instance_info' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/federation/instance_info")

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

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

url = "{{baseUrl}}/vapi/federation/instance_info"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/federation/instance_info"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/federation/instance_info")

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/vapi/federation/instance_info') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    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}}/vapi/federation/instance_info
http GET {{baseUrl}}/vapi/federation/instance_info
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/federation/instance_info
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/federation/instance_info")! 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 List Federated Instances
{{baseUrl}}/vapi/federation/instances
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/federation/instances");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/federation/instances")
require "http/client"

url = "{{baseUrl}}/vapi/federation/instances"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/vapi/federation/instances"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/federation/instances");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/federation/instances"

	req, _ := http.NewRequest("GET", url, nil)

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

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

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

}
GET /baseUrl/vapi/federation/instances HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/federation/instances"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/federation/instances")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/federation/instances")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/vapi/federation/instances');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/federation/instances'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/federation/instances';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/federation/instances',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/federation/instances',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/vapi/federation/instances'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/federation/instances');

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/vapi/federation/instances'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/federation/instances';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/federation/instances"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/federation/instances" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/federation/instances",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/vapi/federation/instances');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/federation/instances');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/federation/instances');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/federation/instances' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/federation/instances' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/federation/instances")

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

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

url = "{{baseUrl}}/vapi/federation/instances"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/federation/instances"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/federation/instances")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/vapi/federation/instances') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/vapi/federation/instances
http GET {{baseUrl}}/vapi/federation/instances
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/federation/instances
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/federation/instances")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
PUT Update Federated Instance Endpoint
{{baseUrl}}/vapi/federation/instance
QUERY PARAMS
instance_name
BODY json
{
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/federation/instance?instance_name=");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/vapi/federation/instance" {:query-params {:instance_name ""}
                                                                    :content-type :json
                                                                    :form-params {:url_address ""
                                                                                  :username ""
                                                                                  :password ""
                                                                                  :enabled ""}})
require "http/client"

url = "{{baseUrl}}/vapi/federation/instance?instance_name="
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\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}}/vapi/federation/instance?instance_name="),
    Content = new StringContent("{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\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}}/vapi/federation/instance?instance_name=");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/federation/instance?instance_name="

	payload := strings.NewReader("{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\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/vapi/federation/instance?instance_name= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 76

{
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/vapi/federation/instance?instance_name=")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/federation/instance?instance_name="))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\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  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/federation/instance?instance_name=")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/vapi/federation/instance?instance_name=")
  .header("content-type", "application/json")
  .body("{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  url_address: '',
  username: '',
  password: '',
  enabled: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/vapi/federation/instance?instance_name=');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/federation/instance',
  params: {instance_name: ''},
  headers: {'content-type': 'application/json'},
  data: {url_address: '', username: '', password: '', enabled: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/federation/instance?instance_name=';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"url_address":"","username":"","password":"","enabled":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/federation/instance?instance_name=',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "url_address": "",\n  "username": "",\n  "password": "",\n  "enabled": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/federation/instance?instance_name=")
  .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/vapi/federation/instance?instance_name=',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({url_address: '', username: '', password: '', enabled: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/federation/instance',
  qs: {instance_name: ''},
  headers: {'content-type': 'application/json'},
  body: {url_address: '', username: '', password: '', enabled: ''},
  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}}/vapi/federation/instance');

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

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

req.type('json');
req.send({
  url_address: '',
  username: '',
  password: '',
  enabled: ''
});

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}}/vapi/federation/instance',
  params: {instance_name: ''},
  headers: {'content-type': 'application/json'},
  data: {url_address: '', username: '', password: '', enabled: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/federation/instance?instance_name=';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"url_address":"","username":"","password":"","enabled":""}'
};

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 = @{ @"url_address": @"",
                              @"username": @"",
                              @"password": @"",
                              @"enabled": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/federation/instance?instance_name="]
                                                       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}}/vapi/federation/instance?instance_name=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/federation/instance?instance_name=",
  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([
    'url_address' => '',
    'username' => '',
    'password' => '',
    'enabled' => ''
  ]),
  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}}/vapi/federation/instance?instance_name=', [
  'body' => '{
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/federation/instance');
$request->setMethod(HTTP_METH_PUT);

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'url_address' => '',
  'username' => '',
  'password' => '',
  'enabled' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'url_address' => '',
  'username' => '',
  'password' => '',
  'enabled' => ''
]));
$request->setRequestUrl('{{baseUrl}}/vapi/federation/instance');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'instance_name' => ''
]));

$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}}/vapi/federation/instance?instance_name=' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/federation/instance?instance_name=' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": ""
}'
import http.client

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

payload = "{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/vapi/federation/instance?instance_name=", payload, headers)

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

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

url = "{{baseUrl}}/vapi/federation/instance"

querystring = {"instance_name":""}

payload = {
    "url_address": "",
    "username": "",
    "password": "",
    "enabled": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/federation/instance"

queryString <- list(instance_name = "")

payload <- "{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/federation/instance?instance_name=")

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  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\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/vapi/federation/instance') do |req|
  req.params['instance_name'] = ''
  req.body = "{\n  \"url_address\": \"\",\n  \"username\": \"\",\n  \"password\": \"\",\n  \"enabled\": \"\"\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}}/vapi/federation/instance";

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

    let payload = json!({
        "url_address": "",
        "username": "",
        "password": "",
        "enabled": ""
    });

    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)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/vapi/federation/instance?instance_name=' \
  --header 'content-type: application/json' \
  --data '{
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": ""
}'
echo '{
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": ""
}' |  \
  http PUT '{{baseUrl}}/vapi/federation/instance?instance_name=' \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "url_address": "",\n  "username": "",\n  "password": "",\n  "enabled": ""\n}' \
  --output-document \
  - '{{baseUrl}}/vapi/federation/instance?instance_name='
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "url_address": "",
  "username": "",
  "password": "",
  "enabled": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/federation/instance?instance_name=")! 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 Clone Flow
{{baseUrl}}/vapi/flows/clone-flow
BODY json
{
  "original_flow_name": "",
  "new_name": "",
  "metadata": {
    "display_name": "",
    "description": "",
    "license": "",
    "required_memory_gb": "",
    "version": ""
  },
  "lora_connection_points": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/clone-flow");

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  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/flows/clone-flow" {:content-type :json
                                                                  :form-params {:original_flow_name ""
                                                                                :new_name ""
                                                                                :metadata {:display_name ""
                                                                                           :description ""
                                                                                           :license ""
                                                                                           :required_memory_gb ""
                                                                                           :version ""}
                                                                                :lora_connection_points ""}})
require "http/client"

url = "{{baseUrl}}/vapi/flows/clone-flow"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\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}}/vapi/flows/clone-flow"),
    Content = new StringContent("{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\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}}/vapi/flows/clone-flow");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/clone-flow"

	payload := strings.NewReader("{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\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/vapi/flows/clone-flow HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 215

{
  "original_flow_name": "",
  "new_name": "",
  "metadata": {
    "display_name": "",
    "description": "",
    "license": "",
    "required_memory_gb": "",
    "version": ""
  },
  "lora_connection_points": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/flows/clone-flow")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/flows/clone-flow"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\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  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/flows/clone-flow")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/flows/clone-flow")
  .header("content-type", "application/json")
  .body("{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  original_flow_name: '',
  new_name: '',
  metadata: {
    display_name: '',
    description: '',
    license: '',
    required_memory_gb: '',
    version: ''
  },
  lora_connection_points: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/flows/clone-flow',
  headers: {'content-type': 'application/json'},
  data: {
    original_flow_name: '',
    new_name: '',
    metadata: {
      display_name: '',
      description: '',
      license: '',
      required_memory_gb: '',
      version: ''
    },
    lora_connection_points: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/clone-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"original_flow_name":"","new_name":"","metadata":{"display_name":"","description":"","license":"","required_memory_gb":"","version":""},"lora_connection_points":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/flows/clone-flow',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "original_flow_name": "",\n  "new_name": "",\n  "metadata": {\n    "display_name": "",\n    "description": "",\n    "license": "",\n    "required_memory_gb": "",\n    "version": ""\n  },\n  "lora_connection_points": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/flows/clone-flow")
  .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/vapi/flows/clone-flow',
  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({
  original_flow_name: '',
  new_name: '',
  metadata: {
    display_name: '',
    description: '',
    license: '',
    required_memory_gb: '',
    version: ''
  },
  lora_connection_points: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/flows/clone-flow',
  headers: {'content-type': 'application/json'},
  body: {
    original_flow_name: '',
    new_name: '',
    metadata: {
      display_name: '',
      description: '',
      license: '',
      required_memory_gb: '',
      version: ''
    },
    lora_connection_points: ''
  },
  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}}/vapi/flows/clone-flow');

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

req.type('json');
req.send({
  original_flow_name: '',
  new_name: '',
  metadata: {
    display_name: '',
    description: '',
    license: '',
    required_memory_gb: '',
    version: ''
  },
  lora_connection_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: 'POST',
  url: '{{baseUrl}}/vapi/flows/clone-flow',
  headers: {'content-type': 'application/json'},
  data: {
    original_flow_name: '',
    new_name: '',
    metadata: {
      display_name: '',
      description: '',
      license: '',
      required_memory_gb: '',
      version: ''
    },
    lora_connection_points: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/flows/clone-flow';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"original_flow_name":"","new_name":"","metadata":{"display_name":"","description":"","license":"","required_memory_gb":"","version":""},"lora_connection_points":""}'
};

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 = @{ @"original_flow_name": @"",
                              @"new_name": @"",
                              @"metadata": @{ @"display_name": @"", @"description": @"", @"license": @"", @"required_memory_gb": @"", @"version": @"" },
                              @"lora_connection_points": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/flows/clone-flow"]
                                                       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}}/vapi/flows/clone-flow" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/clone-flow",
  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([
    'original_flow_name' => '',
    'new_name' => '',
    'metadata' => [
        'display_name' => '',
        'description' => '',
        'license' => '',
        'required_memory_gb' => '',
        'version' => ''
    ],
    'lora_connection_points' => ''
  ]),
  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}}/vapi/flows/clone-flow', [
  'body' => '{
  "original_flow_name": "",
  "new_name": "",
  "metadata": {
    "display_name": "",
    "description": "",
    "license": "",
    "required_memory_gb": "",
    "version": ""
  },
  "lora_connection_points": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/clone-flow');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'original_flow_name' => '',
  'new_name' => '',
  'metadata' => [
    'display_name' => '',
    'description' => '',
    'license' => '',
    'required_memory_gb' => '',
    'version' => ''
  ],
  'lora_connection_points' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'original_flow_name' => '',
  'new_name' => '',
  'metadata' => [
    'display_name' => '',
    'description' => '',
    'license' => '',
    'required_memory_gb' => '',
    'version' => ''
  ],
  'lora_connection_points' => ''
]));
$request->setRequestUrl('{{baseUrl}}/vapi/flows/clone-flow');
$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}}/vapi/flows/clone-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "original_flow_name": "",
  "new_name": "",
  "metadata": {
    "display_name": "",
    "description": "",
    "license": "",
    "required_memory_gb": "",
    "version": ""
  },
  "lora_connection_points": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/clone-flow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "original_flow_name": "",
  "new_name": "",
  "metadata": {
    "display_name": "",
    "description": "",
    "license": "",
    "required_memory_gb": "",
    "version": ""
  },
  "lora_connection_points": ""
}'
import http.client

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

payload = "{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\n}"

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

conn.request("POST", "/baseUrl/vapi/flows/clone-flow", payload, headers)

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

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

url = "{{baseUrl}}/vapi/flows/clone-flow"

payload = {
    "original_flow_name": "",
    "new_name": "",
    "metadata": {
        "display_name": "",
        "description": "",
        "license": "",
        "required_memory_gb": "",
        "version": ""
    },
    "lora_connection_points": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/clone-flow"

payload <- "{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\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}}/vapi/flows/clone-flow")

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  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\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/vapi/flows/clone-flow') do |req|
  req.body = "{\n  \"original_flow_name\": \"\",\n  \"new_name\": \"\",\n  \"metadata\": {\n    \"display_name\": \"\",\n    \"description\": \"\",\n    \"license\": \"\",\n    \"required_memory_gb\": \"\",\n    \"version\": \"\"\n  },\n  \"lora_connection_points\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "original_flow_name": "",
        "new_name": "",
        "metadata": json!({
            "display_name": "",
            "description": "",
            "license": "",
            "required_memory_gb": "",
            "version": ""
        }),
        "lora_connection_points": ""
    });

    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}}/vapi/flows/clone-flow \
  --header 'content-type: application/json' \
  --data '{
  "original_flow_name": "",
  "new_name": "",
  "metadata": {
    "display_name": "",
    "description": "",
    "license": "",
    "required_memory_gb": "",
    "version": ""
  },
  "lora_connection_points": ""
}'
echo '{
  "original_flow_name": "",
  "new_name": "",
  "metadata": {
    "display_name": "",
    "description": "",
    "license": "",
    "required_memory_gb": "",
    "version": ""
  },
  "lora_connection_points": ""
}' |  \
  http POST {{baseUrl}}/vapi/flows/clone-flow \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "original_flow_name": "",\n  "new_name": "",\n  "metadata": {\n    "display_name": "",\n    "description": "",\n    "license": "",\n    "required_memory_gb": "",\n    "version": ""\n  },\n  "lora_connection_points": ""\n}' \
  --output-document \
  - {{baseUrl}}/vapi/flows/clone-flow
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "original_flow_name": "",
  "new_name": "",
  "metadata": [
    "display_name": "",
    "description": "",
    "license": "",
    "required_memory_gb": "",
    "version": ""
  ],
  "lora_connection_points": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/clone-flow")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Installation of this flow is already in progress."
}
DELETE Delete Install Progress
{{baseUrl}}/vapi/flows/install-progress
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/install-progress?name=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/vapi/flows/install-progress" {:query-params {:name ""}})
require "http/client"

url = "{{baseUrl}}/vapi/flows/install-progress?name="

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/vapi/flows/install-progress?name="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/flows/install-progress?name=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/install-progress?name="

	req, _ := http.NewRequest("DELETE", url, nil)

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

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

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

}
DELETE /baseUrl/vapi/flows/install-progress?name= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/vapi/flows/install-progress?name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/flows/install-progress?name="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/flows/install-progress?name=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/vapi/flows/install-progress?name=")
  .asString();
const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/vapi/flows/install-progress?name=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/flows/install-progress',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/install-progress?name=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/flows/install-progress?name=',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/flows/install-progress?name=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/flows/install-progress?name=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/flows/install-progress',
  qs: {name: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/vapi/flows/install-progress');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/flows/install-progress',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/flows/install-progress?name=';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/flows/install-progress?name="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/flows/install-progress?name=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/install-progress?name=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/vapi/flows/install-progress?name=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/install-progress');
$request->setMethod(HTTP_METH_DELETE);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/flows/install-progress');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'name' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/flows/install-progress?name=' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/install-progress?name=' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/vapi/flows/install-progress?name=")

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

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

url = "{{baseUrl}}/vapi/flows/install-progress"

querystring = {"name":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/install-progress"

queryString <- list(name = "")

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/flows/install-progress?name=")

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

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/vapi/flows/install-progress') do |req|
  req.params['name'] = ''
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

    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}}/vapi/flows/install-progress?name='
http DELETE '{{baseUrl}}/vapi/flows/install-progress?name='
wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/vapi/flows/install-progress?name='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/install-progress?name=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Can't find `flow_name`."
}
DELETE Delete
{{baseUrl}}/vapi/flows/flow
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/flow?name=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/vapi/flows/flow" {:query-params {:name ""}})
require "http/client"

url = "{{baseUrl}}/vapi/flows/flow?name="

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/vapi/flows/flow?name="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/flows/flow?name=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/flow?name="

	req, _ := http.NewRequest("DELETE", url, nil)

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

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

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

}
DELETE /baseUrl/vapi/flows/flow?name= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/flows/flow?name="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/flows/flow?name=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/vapi/flows/flow?name=")
  .asString();
const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/vapi/flows/flow?name=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/flows/flow',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/flow?name=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/flows/flow?name=',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/flows/flow?name=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/flows/flow?name=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/flows/flow',
  qs: {name: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/vapi/flows/flow');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/flows/flow',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/flows/flow?name=';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/flows/flow?name="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/flows/flow?name=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/flow?name=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/vapi/flows/flow?name=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/flow');
$request->setMethod(HTTP_METH_DELETE);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/flows/flow');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'name' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/flows/flow?name=' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/flow?name=' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/vapi/flows/flow?name=")

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

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

url = "{{baseUrl}}/vapi/flows/flow"

querystring = {"name":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/flow"

queryString <- list(name = "")

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/flows/flow?name=")

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

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/vapi/flows/flow') do |req|
  req.params['name'] = ''
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

    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}}/vapi/flows/flow?name='
http DELETE '{{baseUrl}}/vapi/flows/flow?name='
wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/vapi/flows/flow?name='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/flow?name=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()
PUT Edit Flow Metadata
{{baseUrl}}/vapi/flows/flow-metadata
QUERY PARAMS
name
BODY json
{
  "display_name": "",
  "description": "",
  "license": "",
  "required_memory_gb": "",
  "version": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/flow-metadata?name=");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/vapi/flows/flow-metadata" {:query-params {:name ""}
                                                                    :content-type :json
                                                                    :form-params {:display_name ""
                                                                                  :description ""
                                                                                  :license ""
                                                                                  :required_memory_gb ""
                                                                                  :version ""}})
require "http/client"

url = "{{baseUrl}}/vapi/flows/flow-metadata?name="
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\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}}/vapi/flows/flow-metadata?name="),
    Content = new StringContent("{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\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}}/vapi/flows/flow-metadata?name=");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/flow-metadata?name="

	payload := strings.NewReader("{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\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/vapi/flows/flow-metadata?name= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "display_name": "",
  "description": "",
  "license": "",
  "required_memory_gb": "",
  "version": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/vapi/flows/flow-metadata?name=")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/flows/flow-metadata?name="))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\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  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/flows/flow-metadata?name=")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/vapi/flows/flow-metadata?name=")
  .header("content-type", "application/json")
  .body("{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  display_name: '',
  description: '',
  license: '',
  required_memory_gb: '',
  version: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/vapi/flows/flow-metadata?name=');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/flows/flow-metadata',
  params: {name: ''},
  headers: {'content-type': 'application/json'},
  data: {
    display_name: '',
    description: '',
    license: '',
    required_memory_gb: '',
    version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/flow-metadata?name=';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"display_name":"","description":"","license":"","required_memory_gb":"","version":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/flows/flow-metadata?name=',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "display_name": "",\n  "description": "",\n  "license": "",\n  "required_memory_gb": "",\n  "version": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/flows/flow-metadata?name=")
  .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/vapi/flows/flow-metadata?name=',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  display_name: '',
  description: '',
  license: '',
  required_memory_gb: '',
  version: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/flows/flow-metadata',
  qs: {name: ''},
  headers: {'content-type': 'application/json'},
  body: {
    display_name: '',
    description: '',
    license: '',
    required_memory_gb: '',
    version: ''
  },
  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}}/vapi/flows/flow-metadata');

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

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

req.type('json');
req.send({
  display_name: '',
  description: '',
  license: '',
  required_memory_gb: '',
  version: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/flows/flow-metadata',
  params: {name: ''},
  headers: {'content-type': 'application/json'},
  data: {
    display_name: '',
    description: '',
    license: '',
    required_memory_gb: '',
    version: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/flows/flow-metadata?name=';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"display_name":"","description":"","license":"","required_memory_gb":"","version":""}'
};

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 = @{ @"display_name": @"",
                              @"description": @"",
                              @"license": @"",
                              @"required_memory_gb": @"",
                              @"version": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/flows/flow-metadata?name="]
                                                       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}}/vapi/flows/flow-metadata?name=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/flow-metadata?name=",
  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([
    'display_name' => '',
    'description' => '',
    'license' => '',
    'required_memory_gb' => '',
    'version' => ''
  ]),
  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}}/vapi/flows/flow-metadata?name=', [
  'body' => '{
  "display_name": "",
  "description": "",
  "license": "",
  "required_memory_gb": "",
  "version": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/flow-metadata');
$request->setMethod(HTTP_METH_PUT);

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'display_name' => '',
  'description' => '',
  'license' => '',
  'required_memory_gb' => '',
  'version' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'display_name' => '',
  'description' => '',
  'license' => '',
  'required_memory_gb' => '',
  'version' => ''
]));
$request->setRequestUrl('{{baseUrl}}/vapi/flows/flow-metadata');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'name' => ''
]));

$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}}/vapi/flows/flow-metadata?name=' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "display_name": "",
  "description": "",
  "license": "",
  "required_memory_gb": "",
  "version": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/flow-metadata?name=' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "display_name": "",
  "description": "",
  "license": "",
  "required_memory_gb": "",
  "version": ""
}'
import http.client

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

payload = "{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/vapi/flows/flow-metadata?name=", payload, headers)

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

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

url = "{{baseUrl}}/vapi/flows/flow-metadata"

querystring = {"name":""}

payload = {
    "display_name": "",
    "description": "",
    "license": "",
    "required_memory_gb": "",
    "version": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/flow-metadata"

queryString <- list(name = "")

payload <- "{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/flows/flow-metadata?name=")

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  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\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/vapi/flows/flow-metadata') do |req|
  req.params['name'] = ''
  req.body = "{\n  \"display_name\": \"\",\n  \"description\": \"\",\n  \"license\": \"\",\n  \"required_memory_gb\": \"\",\n  \"version\": \"\"\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}}/vapi/flows/flow-metadata";

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

    let payload = json!({
        "display_name": "",
        "description": "",
        "license": "",
        "required_memory_gb": "",
        "version": ""
    });

    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)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/vapi/flows/flow-metadata?name=' \
  --header 'content-type: application/json' \
  --data '{
  "display_name": "",
  "description": "",
  "license": "",
  "required_memory_gb": "",
  "version": ""
}'
echo '{
  "display_name": "",
  "description": "",
  "license": "",
  "required_memory_gb": "",
  "version": ""
}' |  \
  http PUT '{{baseUrl}}/vapi/flows/flow-metadata?name=' \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "display_name": "",\n  "description": "",\n  "license": "",\n  "required_memory_gb": "",\n  "version": ""\n}' \
  --output-document \
  - '{{baseUrl}}/vapi/flows/flow-metadata?name='
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "display_name": "",
  "description": "",
  "license": "",
  "required_memory_gb": "",
  "version": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/flow-metadata?name=")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Flow metadata node not found."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Editing flow failed."
}
POST Flow Update
{{baseUrl}}/vapi/flows/flow-update
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/flow-update?name=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/flows/flow-update" {:query-params {:name ""}})
require "http/client"

url = "{{baseUrl}}/vapi/flows/flow-update?name="

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}}/vapi/flows/flow-update?name="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/flows/flow-update?name=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/flow-update?name="

	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/vapi/flows/flow-update?name= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/flows/flow-update?name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/flows/flow-update?name="))
    .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}}/vapi/flows/flow-update?name=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/flows/flow-update?name=")
  .asString();
const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/vapi/flows/flow-update?name=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/flows/flow-update',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/flow-update?name=';
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}}/vapi/flows/flow-update?name=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/flows/flow-update?name=")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/flows/flow-update?name=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/flows/flow-update',
  qs: {name: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/vapi/flows/flow-update');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/flows/flow-update',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/flows/flow-update?name=';
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}}/vapi/flows/flow-update?name="]
                                                       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}}/vapi/flows/flow-update?name=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/flow-update?name=",
  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}}/vapi/flows/flow-update?name=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/flow-update');
$request->setMethod(HTTP_METH_POST);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/flows/flow-update');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'name' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/flows/flow-update?name=' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/flow-update?name=' -Method POST 
import http.client

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

conn.request("POST", "/baseUrl/vapi/flows/flow-update?name=")

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

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

url = "{{baseUrl}}/vapi/flows/flow-update"

querystring = {"name":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/flow-update"

queryString <- list(name = "")

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/flows/flow-update?name=")

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/vapi/flows/flow-update') do |req|
  req.params['name'] = ''
end

puts response.status
puts response.body
use reqwest;

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

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/vapi/flows/flow-update?name='
http POST '{{baseUrl}}/vapi/flows/flow-update?name='
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/vapi/flows/flow-update?name='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/flow-update?name=")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Can't find `flow_name` flow."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Installation of this flow is already in progress."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Flow `flow_name` does not have a newer version."
}
GET Get Flow Details
{{baseUrl}}/vapi/flows/flow-details
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/flow-details?name=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/flows/flow-details" {:query-params {:name ""}})
require "http/client"

url = "{{baseUrl}}/vapi/flows/flow-details?name="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/vapi/flows/flow-details?name="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/flows/flow-details?name=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/flow-details?name="

	req, _ := http.NewRequest("GET", url, nil)

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

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

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

}
GET /baseUrl/vapi/flows/flow-details?name= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vapi/flows/flow-details?name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/flows/flow-details?name="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/flows/flow-details?name=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/flows/flow-details?name=")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/vapi/flows/flow-details?name=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/flows/flow-details',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/flow-details?name=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/flows/flow-details?name=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/flows/flow-details?name=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/flows/flow-details?name=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/flows/flow-details',
  qs: {name: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/flows/flow-details');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/flows/flow-details',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/flows/flow-details?name=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/flows/flow-details?name="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/flows/flow-details?name=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/flow-details?name=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/vapi/flows/flow-details?name=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/flow-details');
$request->setMethod(HTTP_METH_GET);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/flows/flow-details');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'name' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/flows/flow-details?name=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/flow-details?name=' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/flows/flow-details?name=")

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

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

url = "{{baseUrl}}/vapi/flows/flow-details"

querystring = {"name":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/flow-details"

queryString <- list(name = "")

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/flows/flow-details?name=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/vapi/flows/flow-details') do |req|
  req.params['name'] = ''
end

puts response.status
puts response.body
use reqwest;

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

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/vapi/flows/flow-details?name='
http GET '{{baseUrl}}/vapi/flows/flow-details?name='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/vapi/flows/flow-details?name='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/flow-details?name=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET Get Install Progress
{{baseUrl}}/vapi/flows/install-progress
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/install-progress");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/flows/install-progress")
require "http/client"

url = "{{baseUrl}}/vapi/flows/install-progress"

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}}/vapi/flows/install-progress"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/flows/install-progress");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/install-progress"

	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/vapi/flows/install-progress HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/flows/install-progress"))
    .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}}/vapi/flows/install-progress")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/flows/install-progress")
  .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}}/vapi/flows/install-progress');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/flows/install-progress'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/install-progress';
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}}/vapi/flows/install-progress',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/flows/install-progress")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/flows/install-progress');

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}}/vapi/flows/install-progress'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/install-progress",
  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}}/vapi/flows/install-progress');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/install-progress');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/flows/install-progress');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/flows/install-progress' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/install-progress' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/flows/install-progress")

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

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

url = "{{baseUrl}}/vapi/flows/install-progress"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/install-progress"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/flows/install-progress")

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/vapi/flows/install-progress') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    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}}/vapi/flows/install-progress
http GET {{baseUrl}}/vapi/flows/install-progress
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/flows/install-progress
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/install-progress")! 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 Get Installed
{{baseUrl}}/vapi/flows/installed
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/installed");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/flows/installed")
require "http/client"

url = "{{baseUrl}}/vapi/flows/installed"

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}}/vapi/flows/installed"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/flows/installed");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/installed"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/flows/installed")
  .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}}/vapi/flows/installed');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/flows/installed'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/installed';
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}}/vapi/flows/installed',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/flows/installed');

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}}/vapi/flows/installed'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/installed",
  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}}/vapi/flows/installed');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/installed');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/flows/installed');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/flows/installed' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/installed' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/flows/installed")

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

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

url = "{{baseUrl}}/vapi/flows/installed"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/installed"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/flows/installed")

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/vapi/flows/installed') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    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}}/vapi/flows/installed
http GET {{baseUrl}}/vapi/flows/installed
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/flows/installed
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/installed")! 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 Get Not Installed
{{baseUrl}}/vapi/flows/not-installed
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/not-installed");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/flows/not-installed")
require "http/client"

url = "{{baseUrl}}/vapi/flows/not-installed"

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}}/vapi/flows/not-installed"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/flows/not-installed");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/not-installed"

	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/vapi/flows/not-installed HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/flows/not-installed"))
    .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}}/vapi/flows/not-installed")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/flows/not-installed")
  .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}}/vapi/flows/not-installed');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/flows/not-installed'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/not-installed';
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}}/vapi/flows/not-installed',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/flows/not-installed")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/flows/not-installed');

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}}/vapi/flows/not-installed'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/not-installed",
  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}}/vapi/flows/not-installed');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/not-installed');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/flows/not-installed');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/flows/not-installed' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/not-installed' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/flows/not-installed")

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

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

url = "{{baseUrl}}/vapi/flows/not-installed"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/not-installed"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/flows/not-installed")

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/vapi/flows/not-installed') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    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}}/vapi/flows/not-installed
http GET {{baseUrl}}/vapi/flows/not-installed
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/flows/not-installed
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/not-installed")! 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 Get Subflows
{{baseUrl}}/vapi/flows/subflows
QUERY PARAMS
input_type
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/subflows?input_type=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/flows/subflows" {:query-params {:input_type ""}})
require "http/client"

url = "{{baseUrl}}/vapi/flows/subflows?input_type="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/vapi/flows/subflows?input_type="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/flows/subflows?input_type=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/subflows?input_type="

	req, _ := http.NewRequest("GET", url, nil)

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

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

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

}
GET /baseUrl/vapi/flows/subflows?input_type= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/flows/subflows?input_type="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/flows/subflows?input_type=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/flows/subflows?input_type=")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/vapi/flows/subflows?input_type=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/flows/subflows',
  params: {input_type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/subflows?input_type=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/flows/subflows?input_type=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/flows/subflows?input_type=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/flows/subflows?input_type=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/flows/subflows',
  qs: {input_type: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/flows/subflows');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/flows/subflows',
  params: {input_type: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/flows/subflows?input_type=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/flows/subflows?input_type="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/flows/subflows?input_type=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/subflows?input_type=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/vapi/flows/subflows?input_type=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/subflows');
$request->setMethod(HTTP_METH_GET);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/flows/subflows');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'input_type' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/flows/subflows?input_type=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/subflows?input_type=' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/flows/subflows?input_type=")

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

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

url = "{{baseUrl}}/vapi/flows/subflows"

querystring = {"input_type":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/subflows"

queryString <- list(input_type = "")

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/flows/subflows?input_type=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/vapi/flows/subflows') do |req|
  req.params['input_type'] = ''
end

puts response.status
puts response.body
use reqwest;

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

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/vapi/flows/subflows?input_type='
http GET '{{baseUrl}}/vapi/flows/subflows?input_type='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/vapi/flows/subflows?input_type='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/subflows?input_type=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
PUT Install From File
{{baseUrl}}/vapi/flows/flow
BODY multipartForm
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/flow");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/vapi/flows/flow" {:multipart [{:name "flow_file"
                                                                        :content ""}]})
require "http/client"

url = "{{baseUrl}}/vapi/flows/flow"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\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}}/vapi/flows/flow"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "flow_file",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/flows/flow");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/flow"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

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

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

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

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

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

}
PUT /baseUrl/vapi/flows/flow HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 118

-----011000010111000001101001
Content-Disposition: form-data; name="flow_file"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/vapi/flows/flow")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/flows/flow"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("PUT", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/flows/flow")
  .put(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/vapi/flows/flow")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();
const data = new FormData();
data.append('flow_file', '');

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

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

xhr.open('PUT', '{{baseUrl}}/vapi/flows/flow');

xhr.send(data);
import axios from 'axios';

const form = new FormData();
form.append('flow_file', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/flows/flow',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/flow';
const form = new FormData();
form.append('flow_file', '');

const options = {method: 'PUT'};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const form = new FormData();
form.append('flow_file', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/flows/flow',
  method: 'PUT',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/flows/flow")
  .put(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/flows/flow',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

const req = http.request(options, function (res) {
  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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="flow_file"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/flows/flow',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {flow_file: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/vapi/flows/flow');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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}}/vapi/flows/flow',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="flow_file"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('flow_file', '');

const url = '{{baseUrl}}/vapi/flows/flow';
const options = {method: 'PUT'};
options.body = formData;

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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"flow_file", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/flows/flow"]
                                                       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}}/vapi/flows/flow" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/flow",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/vapi/flows/flow', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/flow');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="flow_file"


-----011000010111000001101001--
');

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

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

$request->setRequestUrl('{{baseUrl}}/vapi/flows/flow');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/flows/flow' -Method PUT -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="flow_file"


-----011000010111000001101001--
'
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/flow' -Method PUT -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="flow_file"


-----011000010111000001101001--
'
import http.client

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

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("PUT", "/baseUrl/vapi/flows/flow", payload, headers)

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

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

url = "{{baseUrl}}/vapi/flows/flow"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/flow"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("PUT", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/flows/flow")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.put('/baseUrl/vapi/flows/flow') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"flow_file\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let form = reqwest::multipart::Form::new()
        .text("flow_file", "");
    let mut headers = reqwest::header::HeaderMap::new();

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/vapi/flows/flow \
  --header 'content-type: multipart/form-data' \
  --form flow_file=
echo '-----011000010111000001101001
Content-Disposition: form-data; name="flow_file"


-----011000010111000001101001--
' |  \
  http PUT {{baseUrl}}/vapi/flows/flow \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'
wget --quiet \
  --method PUT \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="flow_file"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/vapi/flows/flow
import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "flow_file",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/flow")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Installation of this flow is already in progress."
}
POST Install
{{baseUrl}}/vapi/flows/flow
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/flows/flow?name=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/flows/flow" {:query-params {:name ""}})
require "http/client"

url = "{{baseUrl}}/vapi/flows/flow?name="

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}}/vapi/flows/flow?name="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/flows/flow?name=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/flows/flow?name="

	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/vapi/flows/flow?name= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/flows/flow?name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/flows/flow?name="))
    .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}}/vapi/flows/flow?name=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/flows/flow?name=")
  .asString();
const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/vapi/flows/flow?name=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/flows/flow',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/flows/flow?name=';
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}}/vapi/flows/flow?name=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/flows/flow?name=")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/flows/flow?name=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/flows/flow',
  qs: {name: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/vapi/flows/flow');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/flows/flow',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/flows/flow?name=';
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}}/vapi/flows/flow?name="]
                                                       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}}/vapi/flows/flow?name=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/flows/flow?name=",
  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}}/vapi/flows/flow?name=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/flows/flow');
$request->setMethod(HTTP_METH_POST);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/flows/flow');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'name' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/flows/flow?name=' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/flows/flow?name=' -Method POST 
import http.client

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

conn.request("POST", "/baseUrl/vapi/flows/flow?name=")

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

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

url = "{{baseUrl}}/vapi/flows/flow"

querystring = {"name":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/flows/flow"

queryString <- list(name = "")

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/flows/flow?name=")

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/vapi/flows/flow') do |req|
  req.params['name'] = ''
end

puts response.status
puts response.body
use reqwest;

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

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

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/vapi/flows/flow?name='
http POST '{{baseUrl}}/vapi/flows/flow?name='
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/vapi/flows/flow?name='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/flows/flow?name=")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Can't find `flow_name` flow."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Installation of this flow is already in progress."
}
DELETE Delete Orphan Model
{{baseUrl}}/vapi/models/orphan
QUERY PARAMS
full_orphan_path
file_creation_time
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/vapi/models/orphan" {:query-params {:full_orphan_path ""
                                                                                :file_creation_time ""}})
require "http/client"

url = "{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time="

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}}/vapi/models/orphan?full_orphan_path=&file_creation_time="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time="

	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/vapi/models/orphan?full_orphan_path=&file_creation_time= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time="))
    .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}}/vapi/models/orphan?full_orphan_path=&file_creation_time=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=")
  .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}}/vapi/models/orphan?full_orphan_path=&file_creation_time=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/models/orphan',
  params: {full_orphan_path: '', file_creation_time: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=';
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}}/vapi/models/orphan?full_orphan_path=&file_creation_time=',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/models/orphan?full_orphan_path=&file_creation_time=',
  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}}/vapi/models/orphan',
  qs: {full_orphan_path: '', file_creation_time: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/vapi/models/orphan');

req.query({
  full_orphan_path: '',
  file_creation_time: ''
});

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}}/vapi/models/orphan',
  params: {full_orphan_path: '', file_creation_time: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=';
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}}/vapi/models/orphan?full_orphan_path=&file_creation_time="]
                                                       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}}/vapi/models/orphan?full_orphan_path=&file_creation_time=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=",
  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}}/vapi/models/orphan?full_orphan_path=&file_creation_time=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/models/orphan');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'full_orphan_path' => '',
  'file_creation_time' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/models/orphan');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'full_orphan_path' => '',
  'file_creation_time' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/vapi/models/orphan?full_orphan_path=&file_creation_time=")

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

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

url = "{{baseUrl}}/vapi/models/orphan"

querystring = {"full_orphan_path":"","file_creation_time":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/models/orphan"

queryString <- list(
  full_orphan_path = "",
  file_creation_time = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=")

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/vapi/models/orphan') do |req|
  req.params['full_orphan_path'] = ''
  req.params['file_creation_time'] = ''
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let querystring = [
        ("full_orphan_path", ""),
        ("file_creation_time", ""),
    ];

    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}}/vapi/models/orphan?full_orphan_path=&file_creation_time='
http DELETE '{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time='
wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/models/orphan?full_orphan_path=&file_creation_time=")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Cannot delete orphan models during ongoing installations."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "File not found at path: /absolute/path/to/models/example_model.ckpt"
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Failed to delete orphan model: Unknown error occurred."
}
GET Get Orphan Models
{{baseUrl}}/vapi/models/orphan
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/models/orphan");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/models/orphan")
require "http/client"

url = "{{baseUrl}}/vapi/models/orphan"

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}}/vapi/models/orphan"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/models/orphan");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/models/orphan"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/models/orphan")
  .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}}/vapi/models/orphan');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/models/orphan'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/models/orphan';
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}}/vapi/models/orphan',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/models/orphan');

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}}/vapi/models/orphan'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/models/orphan",
  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}}/vapi/models/orphan');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/models/orphan');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/models/orphan');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/models/orphan' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/models/orphan' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/models/orphan")

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

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

url = "{{baseUrl}}/vapi/models/orphan"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/models/orphan"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/models/orphan")

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/vapi/models/orphan') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    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}}/vapi/models/orphan
http GET {{baseUrl}}/vapi/models/orphan
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/models/orphan
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/models/orphan")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
  {
    "path": "models/example_model.ckpt",
    "full_path": "/absolute/path/to/models/example_model.ckpt",
    "size": 512.3,
    "creation_time": 1695724800,
    "possible_flows": []
  }
]
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Cannot run orphan models detection during ongoing installations."
}
POST Interrupt Engine
{{baseUrl}}/vapi/other/interrupt-engine
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/other/interrupt-engine");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/other/interrupt-engine")
require "http/client"

url = "{{baseUrl}}/vapi/other/interrupt-engine"

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}}/vapi/other/interrupt-engine"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/other/interrupt-engine");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/other/interrupt-engine"

	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/vapi/other/interrupt-engine HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/other/interrupt-engine")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/other/interrupt-engine"))
    .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}}/vapi/other/interrupt-engine")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/other/interrupt-engine")
  .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}}/vapi/other/interrupt-engine');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/vapi/other/interrupt-engine'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/other/interrupt-engine';
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}}/vapi/other/interrupt-engine',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/other/interrupt-engine")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/other/interrupt-engine',
  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}}/vapi/other/interrupt-engine'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/vapi/other/interrupt-engine');

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}}/vapi/other/interrupt-engine'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/other/interrupt-engine",
  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}}/vapi/other/interrupt-engine');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/other/interrupt-engine');
$request->setMethod(HTTP_METH_POST);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/other/interrupt-engine');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/other/interrupt-engine' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/other/interrupt-engine' -Method POST 
import http.client

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

conn.request("POST", "/baseUrl/vapi/other/interrupt-engine")

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

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

url = "{{baseUrl}}/vapi/other/interrupt-engine"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/other/interrupt-engine"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/other/interrupt-engine")

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/vapi/other/interrupt-engine') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/other/interrupt-engine";

    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}}/vapi/other/interrupt-engine
http POST {{baseUrl}}/vapi/other/interrupt-engine
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/vapi/other/interrupt-engine
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/other/interrupt-engine")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Admin privilege required"
}
POST Shutdown Server
{{baseUrl}}/vapi/other/shutdown-server
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/other/shutdown-server");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/other/shutdown-server")
require "http/client"

url = "{{baseUrl}}/vapi/other/shutdown-server"

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}}/vapi/other/shutdown-server"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/other/shutdown-server");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/other/shutdown-server"

	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/vapi/other/shutdown-server HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/other/shutdown-server")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/other/shutdown-server"))
    .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}}/vapi/other/shutdown-server")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/other/shutdown-server")
  .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}}/vapi/other/shutdown-server');

xhr.send(data);
import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/vapi/other/shutdown-server'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/other/shutdown-server';
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}}/vapi/other/shutdown-server',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/other/shutdown-server")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/other/shutdown-server',
  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}}/vapi/other/shutdown-server'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/vapi/other/shutdown-server');

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}}/vapi/other/shutdown-server'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/other/shutdown-server",
  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}}/vapi/other/shutdown-server');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/other/shutdown-server');
$request->setMethod(HTTP_METH_POST);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/other/shutdown-server');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/other/shutdown-server' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/other/shutdown-server' -Method POST 
import http.client

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

conn.request("POST", "/baseUrl/vapi/other/shutdown-server")

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

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

url = "{{baseUrl}}/vapi/other/shutdown-server"

response = requests.post(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/other/shutdown-server"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/other/shutdown-server")

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/vapi/other/shutdown-server') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/other/shutdown-server";

    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}}/vapi/other/shutdown-server
http POST {{baseUrl}}/vapi/other/shutdown-server
wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/vapi/other/shutdown-server
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/other/shutdown-server")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Admin privilege required"
}
POST Translate Prompt
{{baseUrl}}/vapi/other/translate-prompt
BODY json
{
  "prompt": "",
  "system_prompt": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/other/translate-prompt");

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  \"prompt\": \"\",\n  \"system_prompt\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/other/translate-prompt" {:content-type :json
                                                                        :form-params {:prompt ""
                                                                                      :system_prompt ""}})
require "http/client"

url = "{{baseUrl}}/vapi/other/translate-prompt"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"prompt\": \"\",\n  \"system_prompt\": \"\"\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}}/vapi/other/translate-prompt"),
    Content = new StringContent("{\n  \"prompt\": \"\",\n  \"system_prompt\": \"\"\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}}/vapi/other/translate-prompt");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"prompt\": \"\",\n  \"system_prompt\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/other/translate-prompt"

	payload := strings.NewReader("{\n  \"prompt\": \"\",\n  \"system_prompt\": \"\"\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/vapi/other/translate-prompt HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "prompt": "",
  "system_prompt": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/other/translate-prompt")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"prompt\": \"\",\n  \"system_prompt\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/other/translate-prompt"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"prompt\": \"\",\n  \"system_prompt\": \"\"\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  \"prompt\": \"\",\n  \"system_prompt\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/other/translate-prompt")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/other/translate-prompt")
  .header("content-type", "application/json")
  .body("{\n  \"prompt\": \"\",\n  \"system_prompt\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  prompt: '',
  system_prompt: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/vapi/other/translate-prompt');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/other/translate-prompt',
  headers: {'content-type': 'application/json'},
  data: {prompt: '', system_prompt: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/other/translate-prompt';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"prompt":"","system_prompt":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/other/translate-prompt',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "prompt": "",\n  "system_prompt": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"prompt\": \"\",\n  \"system_prompt\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/other/translate-prompt")
  .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/vapi/other/translate-prompt',
  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({prompt: '', system_prompt: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/other/translate-prompt',
  headers: {'content-type': 'application/json'},
  body: {prompt: '', system_prompt: ''},
  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}}/vapi/other/translate-prompt');

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

req.type('json');
req.send({
  prompt: '',
  system_prompt: ''
});

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}}/vapi/other/translate-prompt',
  headers: {'content-type': 'application/json'},
  data: {prompt: '', system_prompt: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/other/translate-prompt';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"prompt":"","system_prompt":""}'
};

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 = @{ @"prompt": @"",
                              @"system_prompt": @"" };

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

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

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/other/translate-prompt",
  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([
    'prompt' => '',
    'system_prompt' => ''
  ]),
  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}}/vapi/other/translate-prompt', [
  'body' => '{
  "prompt": "",
  "system_prompt": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/other/translate-prompt');
$request->setMethod(HTTP_METH_POST);

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

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'prompt' => '',
  'system_prompt' => ''
]));
$request->setRequestUrl('{{baseUrl}}/vapi/other/translate-prompt');
$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}}/vapi/other/translate-prompt' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "prompt": "",
  "system_prompt": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/other/translate-prompt' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "prompt": "",
  "system_prompt": ""
}'
import http.client

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

payload = "{\n  \"prompt\": \"\",\n  \"system_prompt\": \"\"\n}"

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

conn.request("POST", "/baseUrl/vapi/other/translate-prompt", payload, headers)

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

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

url = "{{baseUrl}}/vapi/other/translate-prompt"

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

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/other/translate-prompt"

payload <- "{\n  \"prompt\": \"\",\n  \"system_prompt\": \"\"\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}}/vapi/other/translate-prompt")

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  \"prompt\": \"\",\n  \"system_prompt\": \"\"\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/vapi/other/translate-prompt') do |req|
  req.body = "{\n  \"prompt\": \"\",\n  \"system_prompt\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/other/translate-prompt";

    let payload = json!({
        "prompt": "",
        "system_prompt": ""
    });

    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}}/vapi/other/translate-prompt \
  --header 'content-type: application/json' \
  --data '{
  "prompt": "",
  "system_prompt": ""
}'
echo '{
  "prompt": "",
  "system_prompt": ""
}' |  \
  http POST {{baseUrl}}/vapi/other/translate-prompt \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "prompt": "",\n  "system_prompt": ""\n}' \
  --output-document \
  - {{baseUrl}}/vapi/other/translate-prompt
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/other/translate-prompt")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "prompt": "Dornröschen",
  "result": "Sleeping Beauty",
  "done_reason": "stop"
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Translation service error"
}
GET Update Status
{{baseUrl}}/vapi/other/update-status
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/other/update-status");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/other/update-status")
require "http/client"

url = "{{baseUrl}}/vapi/other/update-status"

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}}/vapi/other/update-status"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/other/update-status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/other/update-status"

	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/vapi/other/update-status HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/other/update-status"))
    .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}}/vapi/other/update-status")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/other/update-status")
  .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}}/vapi/other/update-status');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/other/update-status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/other/update-status';
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}}/vapi/other/update-status',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/other/update-status")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/other/update-status');

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}}/vapi/other/update-status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/other/update-status",
  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}}/vapi/other/update-status');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/other/update-status');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/other/update-status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/other/update-status' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/other/update-status' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/other/update-status")

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

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

url = "{{baseUrl}}/vapi/other/update-status"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/other/update-status"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/other/update-status")

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/vapi/other/update-status') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/other/update-status";

    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}}/vapi/other/update-status
http GET {{baseUrl}}/vapi/other/update-status
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/other/update-status
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/other/update-status")! 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 Whoami
{{baseUrl}}/vapi/other/whoami
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/other/whoami");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/other/whoami")
require "http/client"

url = "{{baseUrl}}/vapi/other/whoami"

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}}/vapi/other/whoami"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/other/whoami");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/other/whoami"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/other/whoami")
  .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}}/vapi/other/whoami');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/other/whoami'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/other/whoami';
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}}/vapi/other/whoami',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/other/whoami');

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}}/vapi/other/whoami'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/other/whoami",
  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}}/vapi/other/whoami');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/other/whoami');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/other/whoami');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/other/whoami' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/other/whoami' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/other/whoami")

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

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

url = "{{baseUrl}}/vapi/other/whoami"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/other/whoami"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/other/whoami")

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/vapi/other/whoami') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    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}}/vapi/other/whoami
http GET {{baseUrl}}/vapi/other/whoami
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/other/whoami
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/other/whoami")! 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 Comfyui Get Folders Paths
{{baseUrl}}/vapi/settings/comfyui/folders
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/settings/comfyui/folders");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/settings/comfyui/folders")
require "http/client"

url = "{{baseUrl}}/vapi/settings/comfyui/folders"

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}}/vapi/settings/comfyui/folders"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/settings/comfyui/folders");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/settings/comfyui/folders"

	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/vapi/settings/comfyui/folders HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/settings/comfyui/folders"))
    .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}}/vapi/settings/comfyui/folders")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/settings/comfyui/folders")
  .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}}/vapi/settings/comfyui/folders');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/settings/comfyui/folders'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/settings/comfyui/folders';
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}}/vapi/settings/comfyui/folders',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/settings/comfyui/folders")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/settings/comfyui/folders');

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}}/vapi/settings/comfyui/folders'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/settings/comfyui/folders",
  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}}/vapi/settings/comfyui/folders');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/settings/comfyui/folders');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/settings/comfyui/folders');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/settings/comfyui/folders' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/settings/comfyui/folders' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/settings/comfyui/folders")

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

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

url = "{{baseUrl}}/vapi/settings/comfyui/folders"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/settings/comfyui/folders"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/settings/comfyui/folders")

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/vapi/settings/comfyui/folders') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    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}}/vapi/settings/comfyui/folders
http GET {{baseUrl}}/vapi/settings/comfyui/folders
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/settings/comfyui/folders
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/settings/comfyui/folders")! 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 Get All
{{baseUrl}}/vapi/settings/get_all
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/settings/get_all");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/settings/get_all")
require "http/client"

url = "{{baseUrl}}/vapi/settings/get_all"

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}}/vapi/settings/get_all"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/settings/get_all");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/settings/get_all"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/settings/get_all")
  .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}}/vapi/settings/get_all');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/settings/get_all'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/settings/get_all';
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}}/vapi/settings/get_all',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/settings/get_all');

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}}/vapi/settings/get_all'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/settings/get_all",
  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}}/vapi/settings/get_all');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/settings/get_all');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/settings/get_all');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/settings/get_all' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/settings/get_all' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/settings/get_all")

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

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

url = "{{baseUrl}}/vapi/settings/get_all"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/settings/get_all"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/settings/get_all")

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/vapi/settings/get_all') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    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}}/vapi/settings/get_all
http GET {{baseUrl}}/vapi/settings/get_all
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/settings/get_all
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/settings/get_all")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "setting_key": "value"
}
GET Get Global All
{{baseUrl}}/vapi/settings/global_all
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/settings/global_all");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/settings/global_all")
require "http/client"

url = "{{baseUrl}}/vapi/settings/global_all"

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}}/vapi/settings/global_all"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/settings/global_all");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/settings/global_all"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/settings/global_all")
  .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}}/vapi/settings/global_all');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/settings/global_all'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/settings/global_all';
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}}/vapi/settings/global_all',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/settings/global_all');

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}}/vapi/settings/global_all'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/settings/global_all",
  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}}/vapi/settings/global_all');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/settings/global_all');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/settings/global_all');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/settings/global_all' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/settings/global_all' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/settings/global_all")

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

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

url = "{{baseUrl}}/vapi/settings/global_all"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/settings/global_all"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/settings/global_all")

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/vapi/settings/global_all') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    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}}/vapi/settings/global_all
http GET {{baseUrl}}/vapi/settings/global_all
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/settings/global_all
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/settings/global_all")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "global_setting_key": "value"
}
GET Get Global
{{baseUrl}}/vapi/settings/global
QUERY PARAMS
key
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/settings/global?key=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/settings/global" {:query-params {:key ""}})
require "http/client"

url = "{{baseUrl}}/vapi/settings/global?key="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/vapi/settings/global?key="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/settings/global?key=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/settings/global?key="

	req, _ := http.NewRequest("GET", url, nil)

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

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

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

}
GET /baseUrl/vapi/settings/global?key= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/settings/global?key="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/settings/global?key=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/settings/global?key=")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/vapi/settings/global?key=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/settings/global',
  params: {key: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/settings/global?key=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/settings/global?key=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/settings/global?key=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/settings/global?key=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/settings/global',
  qs: {key: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/settings/global');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/settings/global',
  params: {key: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/settings/global?key=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/settings/global?key="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/settings/global?key=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/settings/global?key=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/vapi/settings/global?key=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/settings/global');
$request->setMethod(HTTP_METH_GET);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/settings/global');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'key' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/settings/global?key=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/settings/global?key=' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/settings/global?key=")

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

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

url = "{{baseUrl}}/vapi/settings/global"

querystring = {"key":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/settings/global"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/settings/global?key=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/vapi/settings/global') do |req|
  req.params['key'] = ''
end

puts response.status
puts response.body
use reqwest;

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

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/vapi/settings/global?key='
http GET '{{baseUrl}}/vapi/settings/global?key='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/vapi/settings/global?key='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/settings/global?key=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
value_of_global_setting
GET Get Ollama Models
{{baseUrl}}/vapi/settings/ollama/models
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/settings/ollama/models");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/settings/ollama/models")
require "http/client"

url = "{{baseUrl}}/vapi/settings/ollama/models"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/vapi/settings/ollama/models"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/settings/ollama/models");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/settings/ollama/models"

	req, _ := http.NewRequest("GET", url, nil)

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

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

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

}
GET /baseUrl/vapi/settings/ollama/models HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/settings/ollama/models"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/settings/ollama/models")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/settings/ollama/models")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/vapi/settings/ollama/models');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/settings/ollama/models'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/settings/ollama/models';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/settings/ollama/models',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/settings/ollama/models")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/settings/ollama/models',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/vapi/settings/ollama/models'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/settings/ollama/models');

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/vapi/settings/ollama/models'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/settings/ollama/models';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/settings/ollama/models"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/settings/ollama/models" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/settings/ollama/models",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/vapi/settings/ollama/models');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/settings/ollama/models');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/settings/ollama/models');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/settings/ollama/models' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/settings/ollama/models' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/settings/ollama/models")

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

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

url = "{{baseUrl}}/vapi/settings/ollama/models"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/settings/ollama/models"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/settings/ollama/models")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/vapi/settings/ollama/models') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/vapi/settings/ollama/models
http GET {{baseUrl}}/vapi/settings/ollama/models
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/settings/ollama/models
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/settings/ollama/models")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Admin privilege required"
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Invalid Ollama URL configured or error fetching models."
}
GET Get User All
{{baseUrl}}/vapi/settings/user_all
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/settings/user_all");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/settings/user_all")
require "http/client"

url = "{{baseUrl}}/vapi/settings/user_all"

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}}/vapi/settings/user_all"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/settings/user_all");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/settings/user_all"

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


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

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

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/settings/user_all")
  .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}}/vapi/settings/user_all');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/settings/user_all'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/settings/user_all';
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}}/vapi/settings/user_all',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

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

val response = client.newCall(request).execute()
const http = require('https');

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

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/settings/user_all');

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}}/vapi/settings/user_all'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/settings/user_all",
  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}}/vapi/settings/user_all');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/settings/user_all');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/settings/user_all');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/settings/user_all' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/settings/user_all' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/settings/user_all")

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

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

url = "{{baseUrl}}/vapi/settings/user_all"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/settings/user_all"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/settings/user_all")

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/vapi/settings/user_all') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    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}}/vapi/settings/user_all
http GET {{baseUrl}}/vapi/settings/user_all
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/settings/user_all
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/settings/user_all")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "user_setting_key": "value"
}
GET Get User
{{baseUrl}}/vapi/settings/user
QUERY PARAMS
key
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/settings/user?key=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/settings/user" {:query-params {:key ""}})
require "http/client"

url = "{{baseUrl}}/vapi/settings/user?key="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/vapi/settings/user?key="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/settings/user?key=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/settings/user?key="

	req, _ := http.NewRequest("GET", url, nil)

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

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

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

}
GET /baseUrl/vapi/settings/user?key= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/settings/user?key="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/settings/user?key=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/settings/user?key=")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/vapi/settings/user?key=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/settings/user',
  params: {key: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/settings/user?key=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/settings/user?key=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/settings/user?key=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/settings/user?key=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/settings/user',
  qs: {key: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/settings/user');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/settings/user',
  params: {key: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/settings/user?key=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/settings/user?key="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/settings/user?key=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/settings/user?key=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/vapi/settings/user?key=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/settings/user');
$request->setMethod(HTTP_METH_GET);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/settings/user');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'key' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/settings/user?key=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/settings/user?key=' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/settings/user?key=")

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

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

url = "{{baseUrl}}/vapi/settings/user"

querystring = {"key":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/settings/user"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/settings/user?key=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/vapi/settings/user') do |req|
  req.params['key'] = ''
end

puts response.status
puts response.body
use reqwest;

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

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/vapi/settings/user?key='
http GET '{{baseUrl}}/vapi/settings/user?key='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/vapi/settings/user?key='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/settings/user?key=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
value_of_user_setting
GET Get
{{baseUrl}}/vapi/settings/get
QUERY PARAMS
key
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/settings/get?key=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/settings/get" {:query-params {:key ""}})
require "http/client"

url = "{{baseUrl}}/vapi/settings/get?key="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/vapi/settings/get?key="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/settings/get?key=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/settings/get?key="

	req, _ := http.NewRequest("GET", url, nil)

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

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

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

}
GET /baseUrl/vapi/settings/get?key= HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/settings/get?key="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/settings/get?key=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/settings/get?key=")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/vapi/settings/get?key=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/settings/get',
  params: {key: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/settings/get?key=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/settings/get?key=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/settings/get?key=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/settings/get?key=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/settings/get',
  qs: {key: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/settings/get');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/settings/get',
  params: {key: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/settings/get?key=';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/settings/get?key="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/settings/get?key=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/settings/get?key=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/vapi/settings/get?key=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/settings/get');
$request->setMethod(HTTP_METH_GET);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/settings/get');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'key' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/settings/get?key=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/settings/get?key=' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/settings/get?key=")

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

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

url = "{{baseUrl}}/vapi/settings/get"

querystring = {"key":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/settings/get"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/settings/get?key=")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/vapi/settings/get') do |req|
  req.params['key'] = ''
end

puts response.status
puts response.body
use reqwest;

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

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/vapi/settings/get?key='
http GET '{{baseUrl}}/vapi/settings/get?key='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/vapi/settings/get?key='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/settings/get?key=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
text/plain
RESPONSE BODY text
value_of_setting
POST Set Global
{{baseUrl}}/vapi/settings/global
BODY json
{
  "key": "",
  "value": "",
  "sensitive": false
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/settings/global");

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  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/settings/global" {:content-type :json
                                                                 :form-params {:key ""
                                                                               :value ""
                                                                               :sensitive false}})
require "http/client"

url = "{{baseUrl}}/vapi/settings/global"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/vapi/settings/global"),
    Content = new StringContent("{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/settings/global");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/settings/global"

	payload := strings.NewReader("{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}")

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

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

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

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

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

}
POST /baseUrl/vapi/settings/global HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 52

{
  "key": "",
  "value": "",
  "sensitive": false
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/settings/global")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/settings/global"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/settings/global")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/settings/global")
  .header("content-type", "application/json")
  .body("{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}")
  .asString();
const data = JSON.stringify({
  key: '',
  value: '',
  sensitive: false
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/settings/global',
  headers: {'content-type': 'application/json'},
  data: {key: '', value: '', sensitive: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/settings/global';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"key":"","value":"","sensitive":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/settings/global',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "key": "",\n  "value": "",\n  "sensitive": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/settings/global")
  .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/vapi/settings/global',
  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({key: '', value: '', sensitive: false}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/settings/global',
  headers: {'content-type': 'application/json'},
  body: {key: '', value: '', sensitive: false},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/vapi/settings/global');

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

req.type('json');
req.send({
  key: '',
  value: '',
  sensitive: false
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/settings/global',
  headers: {'content-type': 'application/json'},
  data: {key: '', value: '', sensitive: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/settings/global';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"key":"","value":"","sensitive":false}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"key": @"",
                              @"value": @"",
                              @"sensitive": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/settings/global"]
                                                       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}}/vapi/settings/global" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/settings/global",
  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([
    'key' => '',
    'value' => '',
    'sensitive' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/vapi/settings/global', [
  'body' => '{
  "key": "",
  "value": "",
  "sensitive": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/settings/global');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'key' => '',
  'value' => '',
  'sensitive' => null
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'key' => '',
  'value' => '',
  'sensitive' => null
]));
$request->setRequestUrl('{{baseUrl}}/vapi/settings/global');
$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}}/vapi/settings/global' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "key": "",
  "value": "",
  "sensitive": false
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/settings/global' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "key": "",
  "value": "",
  "sensitive": false
}'
import http.client

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

payload = "{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}"

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

conn.request("POST", "/baseUrl/vapi/settings/global", payload, headers)

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

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

url = "{{baseUrl}}/vapi/settings/global"

payload = {
    "key": "",
    "value": "",
    "sensitive": False
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/settings/global"

payload <- "{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}"

encode <- "json"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/settings/global")

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  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/vapi/settings/global') do |req|
  req.body = "{\n  \"key\": \"\",\n  \"value\": \"\",\n  \"sensitive\": false\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "key": "",
        "value": "",
        "sensitive": false
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/vapi/settings/global \
  --header 'content-type: application/json' \
  --data '{
  "key": "",
  "value": "",
  "sensitive": false
}'
echo '{
  "key": "",
  "value": "",
  "sensitive": false
}' |  \
  http POST {{baseUrl}}/vapi/settings/global \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "key": "",\n  "value": "",\n  "sensitive": false\n}' \
  --output-document \
  - {{baseUrl}}/vapi/settings/global
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "key": "",
  "value": "",
  "sensitive": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/settings/global")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Admin privilege required"
}
POST Set User
{{baseUrl}}/vapi/settings/user
BODY json
{
  "key": "",
  "value": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/settings/user");

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  \"key\": \"\",\n  \"value\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/settings/user" {:content-type :json
                                                               :form-params {:key ""
                                                                             :value ""}})
require "http/client"

url = "{{baseUrl}}/vapi/settings/user"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"key\": \"\",\n  \"value\": \"\"\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}}/vapi/settings/user"),
    Content = new StringContent("{\n  \"key\": \"\",\n  \"value\": \"\"\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}}/vapi/settings/user");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"key\": \"\",\n  \"value\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/settings/user"

	payload := strings.NewReader("{\n  \"key\": \"\",\n  \"value\": \"\"\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/vapi/settings/user HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 30

{
  "key": "",
  "value": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/settings/user")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"key\": \"\",\n  \"value\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/settings/user"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"key\": \"\",\n  \"value\": \"\"\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  \"key\": \"\",\n  \"value\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/settings/user")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/settings/user")
  .header("content-type", "application/json")
  .body("{\n  \"key\": \"\",\n  \"value\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  key: '',
  value: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/settings/user',
  headers: {'content-type': 'application/json'},
  data: {key: '', value: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/settings/user';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"key":"","value":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/settings/user',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "key": "",\n  "value": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"key\": \"\",\n  \"value\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/settings/user")
  .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/vapi/settings/user',
  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({key: '', value: ''}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/settings/user',
  headers: {'content-type': 'application/json'},
  body: {key: '', value: ''},
  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}}/vapi/settings/user');

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

req.type('json');
req.send({
  key: '',
  value: ''
});

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}}/vapi/settings/user',
  headers: {'content-type': 'application/json'},
  data: {key: '', value: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/settings/user';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"key":"","value":""}'
};

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 = @{ @"key": @"",
                              @"value": @"" };

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

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

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/settings/user",
  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([
    'key' => '',
    'value' => ''
  ]),
  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}}/vapi/settings/user', [
  'body' => '{
  "key": "",
  "value": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/settings/user');
$request->setMethod(HTTP_METH_POST);

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

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'key' => '',
  'value' => ''
]));
$request->setRequestUrl('{{baseUrl}}/vapi/settings/user');
$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}}/vapi/settings/user' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "key": "",
  "value": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/settings/user' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "key": "",
  "value": ""
}'
import http.client

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

payload = "{\n  \"key\": \"\",\n  \"value\": \"\"\n}"

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

conn.request("POST", "/baseUrl/vapi/settings/user", payload, headers)

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

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

url = "{{baseUrl}}/vapi/settings/user"

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

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/settings/user"

payload <- "{\n  \"key\": \"\",\n  \"value\": \"\"\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}}/vapi/settings/user")

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  \"key\": \"\",\n  \"value\": \"\"\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/vapi/settings/user') do |req|
  req.body = "{\n  \"key\": \"\",\n  \"value\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "key": "",
        "value": ""
    });

    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}}/vapi/settings/user \
  --header 'content-type: application/json' \
  --data '{
  "key": "",
  "value": ""
}'
echo '{
  "key": "",
  "value": ""
}' |  \
  http POST {{baseUrl}}/vapi/settings/user \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "key": "",\n  "value": ""\n}' \
  --output-document \
  - {{baseUrl}}/vapi/settings/user
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/settings/user")! 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 Clear Tasks
{{baseUrl}}/vapi/tasks/clear
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/clear?name=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/vapi/tasks/clear" {:query-params {:name ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/clear?name="

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/vapi/tasks/clear?name="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/clear?name=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/tasks/clear?name="

	req, _ := http.NewRequest("DELETE", url, nil)

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

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

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

}
DELETE /baseUrl/vapi/tasks/clear?name= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/vapi/tasks/clear?name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/clear?name="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/clear?name=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/vapi/tasks/clear?name=")
  .asString();
const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/vapi/tasks/clear?name=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/clear',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/clear?name=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/clear?name=',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/clear?name=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/clear?name=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/clear',
  qs: {name: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/vapi/tasks/clear');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/clear',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/clear?name=';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/clear?name="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/tasks/clear?name=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/clear?name=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/vapi/tasks/clear?name=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/clear');
$request->setMethod(HTTP_METH_DELETE);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/tasks/clear');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'name' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/clear?name=' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/clear?name=' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/vapi/tasks/clear?name=")

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

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

url = "{{baseUrl}}/vapi/tasks/clear"

querystring = {"name":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/clear"

queryString <- list(name = "")

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/clear?name=")

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

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/vapi/tasks/clear') do |req|
  req.params['name'] = ''
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

    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}}/vapi/tasks/clear?name='
http DELETE '{{baseUrl}}/vapi/tasks/clear?name='
wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/vapi/tasks/clear?name='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/clear?name=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()
PUT Create Task Sync
{{baseUrl}}/vapi/tasks/create-sync/:name
QUERY PARAMS
name
BODY formUrlEncoded
group_scope
priority
child_task
webhook_url
webhook_headers
seed
count
translate
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/create-sync/:name");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/vapi/tasks/create-sync/:name" {:form-params {:group_scope ""
                                                                                      :priority ""
                                                                                      :child_task ""
                                                                                      :webhook_url ""
                                                                                      :webhook_headers ""
                                                                                      :seed ""
                                                                                      :count ""
                                                                                      :translate ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/create-sync/:name"
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate="

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}}/vapi/tasks/create-sync/:name"),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "group_scope", "" },
        { "priority", "" },
        { "child_task", "" },
        { "webhook_url", "" },
        { "webhook_headers", "" },
        { "seed", "" },
        { "count", "" },
        { "translate", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/create-sync/:name");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/tasks/create-sync/:name"

	payload := strings.NewReader("group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=")

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

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}
PUT /baseUrl/vapi/tasks/create-sync/:name HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 88

group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/vapi/tasks/create-sync/:name")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/create-sync/:name"))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/create-sync/:name")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/vapi/tasks/create-sync/:name")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=")
  .asString();
const data = 'group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=';

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

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

xhr.open('PUT', '{{baseUrl}}/vapi/tasks/create-sync/:name');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('group_scope', '');
encodedParams.set('priority', '');
encodedParams.set('child_task', '');
encodedParams.set('webhook_url', '');
encodedParams.set('webhook_headers', '');
encodedParams.set('seed', '');
encodedParams.set('count', '');
encodedParams.set('translate', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/create-sync/:name',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/create-sync/:name';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    group_scope: '',
    priority: '',
    child_task: '',
    webhook_url: '',
    webhook_headers: '',
    seed: '',
    count: '',
    translate: ''
  })
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/create-sync/:name',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    group_scope: '',
    priority: '',
    child_task: '',
    webhook_url: '',
    webhook_headers: '',
    seed: '',
    count: '',
    translate: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/create-sync/:name")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/create-sync/:name',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  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(qs.stringify({
  group_scope: '',
  priority: '',
  child_task: '',
  webhook_url: '',
  webhook_headers: '',
  seed: '',
  count: '',
  translate: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/create-sync/:name',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {
    group_scope: '',
    priority: '',
    child_task: '',
    webhook_url: '',
    webhook_headers: '',
    seed: '',
    count: '',
    translate: ''
  }
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/vapi/tasks/create-sync/:name');

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  group_scope: '',
  priority: '',
  child_task: '',
  webhook_url: '',
  webhook_headers: '',
  seed: '',
  count: '',
  translate: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('group_scope', '');
encodedParams.set('priority', '');
encodedParams.set('child_task', '');
encodedParams.set('webhook_url', '');
encodedParams.set('webhook_headers', '');
encodedParams.set('seed', '');
encodedParams.set('count', '');
encodedParams.set('translate', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/create-sync/:name',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('group_scope', '');
encodedParams.set('priority', '');
encodedParams.set('child_task', '');
encodedParams.set('webhook_url', '');
encodedParams.set('webhook_headers', '');
encodedParams.set('seed', '');
encodedParams.set('count', '');
encodedParams.set('translate', '');

const url = '{{baseUrl}}/vapi/tasks/create-sync/:name';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"group_scope=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&priority=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&child_task=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&webhook_url=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&webhook_headers=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&seed=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&count=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&translate=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/create-sync/:name"]
                                                       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}}/vapi/tasks/create-sync/:name" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/create-sync/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/vapi/tasks/create-sync/:name', [
  'form_params' => [
    'group_scope' => '',
    'priority' => '',
    'child_task' => '',
    'webhook_url' => '',
    'webhook_headers' => '',
    'seed' => '',
    'count' => '',
    'translate' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/create-sync/:name');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'group_scope' => '',
  'priority' => '',
  'child_task' => '',
  'webhook_url' => '',
  'webhook_headers' => '',
  'seed' => '',
  'count' => '',
  'translate' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'group_scope' => '',
  'priority' => '',
  'child_task' => '',
  'webhook_url' => '',
  'webhook_headers' => '',
  'seed' => '',
  'count' => '',
  'translate' => ''
]));

$request->setRequestUrl('{{baseUrl}}/vapi/tasks/create-sync/:name');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/create-sync/:name' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate='
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/create-sync/:name' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate='
import http.client

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

payload = "group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/vapi/tasks/create-sync/:name", payload, headers)

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

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

url = "{{baseUrl}}/vapi/tasks/create-sync/:name"

payload = {
    "group_scope": "",
    "priority": "",
    "child_task": "",
    "webhook_url": "",
    "webhook_headers": "",
    "seed": "",
    "count": "",
    "translate": ""
}
headers = {"content-type": "application/x-www-form-urlencoded"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/create-sync/:name"

payload <- "group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate="

encode <- "form"

response <- VERB("PUT", url, body = payload, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/create-sync/:name")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate="

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :group_scope => "",
  :priority => "",
  :child_task => "",
  :webhook_url => "",
  :webhook_headers => "",
  :seed => "",
  :count => "",
  :translate => "",
}

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

response = conn.put('/baseUrl/vapi/tasks/create-sync/:name') do |req|
  req.body = URI.encode_www_form(data)
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}}/vapi/tasks/create-sync/:name";

    let payload = json!({
        "group_scope": "",
        "priority": "",
        "child_task": "",
        "webhook_url": "",
        "webhook_headers": "",
        "seed": "",
        "count": "",
        "translate": ""
    });

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

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/vapi/tasks/create-sync/:name \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data group_scope= \
  --data priority= \
  --data child_task= \
  --data webhook_url= \
  --data webhook_headers= \
  --data seed= \
  --data count= \
  --data translate=
http --form PUT {{baseUrl}}/vapi/tasks/create-sync/:name \
  content-type:application/x-www-form-urlencoded \
  group_scope='' \
  priority='' \
  child_task='' \
  webhook_url='' \
  webhook_headers='' \
  seed='' \
  count='' \
  translate=''
wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'group_scope=&priority=&child_task=&webhook_url=&webhook_headers=&seed=&count=&translate=' \
  --output-document \
  - {{baseUrl}}/vapi/tasks/create-sync/:name
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "group_scope=".data(using: String.Encoding.utf8)!)
postData.append("&priority=".data(using: String.Encoding.utf8)!)
postData.append("&child_task=".data(using: String.Encoding.utf8)!)
postData.append("&webhook_url=".data(using: String.Encoding.utf8)!)
postData.append("&webhook_headers=".data(using: String.Encoding.utf8)!)
postData.append("&seed=".data(using: String.Encoding.utf8)!)
postData.append("&count=".data(using: String.Encoding.utf8)!)
postData.append("&translate=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/create-sync/:name")! 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 Create Task
{{baseUrl}}/vapi/tasks/create/:name
QUERY PARAMS
name
BODY multipartForm
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/create/:name");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/vapi/tasks/create/:name" {:multipart [{:name "group_scope"
                                                                                :content ""} {:name "priority"
                                                                                :content ""} {:name "child_task"
                                                                                :content ""} {:name "webhook_url"
                                                                                :content ""} {:name "webhook_headers"
                                                                                :content ""} {:name "seed"
                                                                                :content ""} {:name "count"
                                                                                :content ""} {:name "translate"
                                                                                :content ""}]})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/create/:name"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\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}}/vapi/tasks/create/:name"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "group_scope",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "priority",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "child_task",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "webhook_url",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "webhook_headers",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "seed",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "count",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "translate",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/create/:name");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/tasks/create/:name"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

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

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

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

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

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

}
PUT /baseUrl/vapi/tasks/create/:name HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 714

-----011000010111000001101001
Content-Disposition: form-data; name="group_scope"


-----011000010111000001101001
Content-Disposition: form-data; name="priority"


-----011000010111000001101001
Content-Disposition: form-data; name="child_task"


-----011000010111000001101001
Content-Disposition: form-data; name="webhook_url"


-----011000010111000001101001
Content-Disposition: form-data; name="webhook_headers"


-----011000010111000001101001
Content-Disposition: form-data; name="seed"


-----011000010111000001101001
Content-Disposition: form-data; name="count"


-----011000010111000001101001
Content-Disposition: form-data; name="translate"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/vapi/tasks/create/:name")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/create/:name"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("PUT", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/create/:name")
  .put(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/vapi/tasks/create/:name")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();
const data = new FormData();
data.append('group_scope', '');
data.append('priority', '');
data.append('child_task', '');
data.append('webhook_url', '');
data.append('webhook_headers', '');
data.append('seed', '');
data.append('count', '');
data.append('translate', '');

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

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

xhr.open('PUT', '{{baseUrl}}/vapi/tasks/create/:name');

xhr.send(data);
import axios from 'axios';

const form = new FormData();
form.append('group_scope', '');
form.append('priority', '');
form.append('child_task', '');
form.append('webhook_url', '');
form.append('webhook_headers', '');
form.append('seed', '');
form.append('count', '');
form.append('translate', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/create/:name',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/create/:name';
const form = new FormData();
form.append('group_scope', '');
form.append('priority', '');
form.append('child_task', '');
form.append('webhook_url', '');
form.append('webhook_headers', '');
form.append('seed', '');
form.append('count', '');
form.append('translate', '');

const options = {method: 'PUT'};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const form = new FormData();
form.append('group_scope', '');
form.append('priority', '');
form.append('child_task', '');
form.append('webhook_url', '');
form.append('webhook_headers', '');
form.append('seed', '');
form.append('count', '');
form.append('translate', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/create/:name',
  method: 'PUT',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/create/:name")
  .put(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/create/:name',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

const req = http.request(options, function (res) {
  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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="group_scope"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="priority"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="child_task"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="webhook_url"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="webhook_headers"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="seed"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="count"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="translate"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/create/:name',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {
    group_scope: '',
    priority: '',
    child_task: '',
    webhook_url: '',
    webhook_headers: '',
    seed: '',
    count: '',
    translate: ''
  }
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/vapi/tasks/create/:name');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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}}/vapi/tasks/create/:name',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="group_scope"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="priority"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="child_task"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="webhook_url"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="webhook_headers"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="seed"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="count"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="translate"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('group_scope', '');
formData.append('priority', '');
formData.append('child_task', '');
formData.append('webhook_url', '');
formData.append('webhook_headers', '');
formData.append('seed', '');
formData.append('count', '');
formData.append('translate', '');

const url = '{{baseUrl}}/vapi/tasks/create/:name';
const options = {method: 'PUT'};
options.body = formData;

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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"group_scope", @"value": @"" },
                         @{ @"name": @"priority", @"value": @"" },
                         @{ @"name": @"child_task", @"value": @"" },
                         @{ @"name": @"webhook_url", @"value": @"" },
                         @{ @"name": @"webhook_headers", @"value": @"" },
                         @{ @"name": @"seed", @"value": @"" },
                         @{ @"name": @"count", @"value": @"" },
                         @{ @"name": @"translate", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/create/:name"]
                                                       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}}/vapi/tasks/create/:name" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/create/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/vapi/tasks/create/:name', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/create/:name');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="group_scope"


-----011000010111000001101001
Content-Disposition: form-data; name="priority"


-----011000010111000001101001
Content-Disposition: form-data; name="child_task"


-----011000010111000001101001
Content-Disposition: form-data; name="webhook_url"


-----011000010111000001101001
Content-Disposition: form-data; name="webhook_headers"


-----011000010111000001101001
Content-Disposition: form-data; name="seed"


-----011000010111000001101001
Content-Disposition: form-data; name="count"


-----011000010111000001101001
Content-Disposition: form-data; name="translate"


-----011000010111000001101001--
');

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

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

$request->setRequestUrl('{{baseUrl}}/vapi/tasks/create/:name');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/create/:name' -Method PUT -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="group_scope"


-----011000010111000001101001
Content-Disposition: form-data; name="priority"


-----011000010111000001101001
Content-Disposition: form-data; name="child_task"


-----011000010111000001101001
Content-Disposition: form-data; name="webhook_url"


-----011000010111000001101001
Content-Disposition: form-data; name="webhook_headers"


-----011000010111000001101001
Content-Disposition: form-data; name="seed"


-----011000010111000001101001
Content-Disposition: form-data; name="count"


-----011000010111000001101001
Content-Disposition: form-data; name="translate"


-----011000010111000001101001--
'
$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/create/:name' -Method PUT -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="group_scope"


-----011000010111000001101001
Content-Disposition: form-data; name="priority"


-----011000010111000001101001
Content-Disposition: form-data; name="child_task"


-----011000010111000001101001
Content-Disposition: form-data; name="webhook_url"


-----011000010111000001101001
Content-Disposition: form-data; name="webhook_headers"


-----011000010111000001101001
Content-Disposition: form-data; name="seed"


-----011000010111000001101001
Content-Disposition: form-data; name="count"


-----011000010111000001101001
Content-Disposition: form-data; name="translate"


-----011000010111000001101001--
'
import http.client

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

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("PUT", "/baseUrl/vapi/tasks/create/:name", payload, headers)

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

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

url = "{{baseUrl}}/vapi/tasks/create/:name"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/create/:name"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("PUT", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/create/:name")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.put('/baseUrl/vapi/tasks/create/:name') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"group_scope\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"priority\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"child_task\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_url\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_headers\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"seed\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"count\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"translate\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let form = reqwest::multipart::Form::new()
        .text("group_scope", "")
        .text("priority", "")
        .text("child_task", "")
        .text("webhook_url", "")
        .text("webhook_headers", "")
        .text("seed", "")
        .text("count", "")
        .text("translate", "");
    let mut headers = reqwest::header::HeaderMap::new();

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/vapi/tasks/create/:name \
  --header 'content-type: multipart/form-data' \
  --form group_scope= \
  --form priority= \
  --form child_task= \
  --form webhook_url= \
  --form webhook_headers= \
  --form seed= \
  --form count= \
  --form translate=
echo '-----011000010111000001101001
Content-Disposition: form-data; name="group_scope"


-----011000010111000001101001
Content-Disposition: form-data; name="priority"


-----011000010111000001101001
Content-Disposition: form-data; name="child_task"


-----011000010111000001101001
Content-Disposition: form-data; name="webhook_url"


-----011000010111000001101001
Content-Disposition: form-data; name="webhook_headers"


-----011000010111000001101001
Content-Disposition: form-data; name="seed"


-----011000010111000001101001
Content-Disposition: form-data; name="count"


-----011000010111000001101001
Content-Disposition: form-data; name="translate"


-----011000010111000001101001--
' |  \
  http PUT {{baseUrl}}/vapi/tasks/create/:name \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'
wget --quiet \
  --method PUT \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="group_scope"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="priority"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="child_task"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="webhook_url"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="webhook_headers"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="seed"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="count"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="translate"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/vapi/tasks/create/:name
import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "group_scope",
    "value": ""
  ],
  [
    "name": "priority",
    "value": ""
  ],
  [
    "name": "child_task",
    "value": ""
  ],
  [
    "name": "webhook_url",
    "value": ""
  ],
  [
    "name": "webhook_headers",
    "value": ""
  ],
  [
    "name": "seed",
    "value": ""
  ],
  [
    "name": "count",
    "value": ""
  ],
  [
    "name": "translate",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

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

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

dataTask.resume()
DELETE Delete Task
{{baseUrl}}/vapi/tasks/task
QUERY PARAMS
task_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/task?task_id=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/vapi/tasks/task" {:query-params {:task_id ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/task?task_id="

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/vapi/tasks/task?task_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/task?task_id=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/tasks/task?task_id="

	req, _ := http.NewRequest("DELETE", url, nil)

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

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

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

}
DELETE /baseUrl/vapi/tasks/task?task_id= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/vapi/tasks/task?task_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/task?task_id="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/task?task_id=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/vapi/tasks/task?task_id=")
  .asString();
const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/vapi/tasks/task?task_id=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/task',
  params: {task_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/task?task_id=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/task?task_id=',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/task?task_id=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/task?task_id=',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/task',
  qs: {task_id: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/vapi/tasks/task');

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

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/task',
  params: {task_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/task?task_id=';
const options = {method: 'DELETE'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/task?task_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/tasks/task?task_id=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/task?task_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/vapi/tasks/task?task_id=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/task');
$request->setMethod(HTTP_METH_DELETE);

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

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/tasks/task');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'task_id' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/task?task_id=' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/task?task_id=' -Method DELETE 
import http.client

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

conn.request("DELETE", "/baseUrl/vapi/tasks/task?task_id=")

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

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

url = "{{baseUrl}}/vapi/tasks/task"

querystring = {"task_id":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/task"

queryString <- list(task_id = "")

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/task?task_id=")

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

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/vapi/tasks/task') do |req|
  req.params['task_id'] = ''
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

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

    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}}/vapi/tasks/task?task_id='
http DELETE '{{baseUrl}}/vapi/tasks/task?task_id='
wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/vapi/tasks/task?task_id='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/task?task_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task `{task_id}` was not found."
}
POST Get Next Task
{{baseUrl}}/vapi/tasks/next
BODY json
{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "tasks_names": [],
  "last_task_name": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/next");

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  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/tasks/next" {:content-type :json
                                                            :form-params {:worker_details {:worker_version ""
                                                                                           :pytorch_version ""
                                                                                           :system {:hostname ""
                                                                                                    :os ""
                                                                                                    :version ""
                                                                                                    :embedded_python false}
                                                                                           :devices [{:name ""
                                                                                                      :type ""
                                                                                                      :index 0
                                                                                                      :vram_total 0
                                                                                                      :vram_free 0
                                                                                                      :torch_vram_total 0
                                                                                                      :torch_vram_free 0}]
                                                                                           :ram_total 0
                                                                                           :ram_free 0
                                                                                           :last_seen ""
                                                                                           :engine_details {:disable_smart_memory ""
                                                                                                            :vram_state ""
                                                                                                            :cache_type ""
                                                                                                            :cache_size 0
                                                                                                            :vae_cpu false
                                                                                                            :reserve_vram ""}}
                                                                          :tasks_names []
                                                                          :last_task_name ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/next"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\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}}/vapi/tasks/next"),
    Content = new StringContent("{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/next");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/tasks/next"

	payload := strings.NewReader("{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\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/vapi/tasks/next HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 693

{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "tasks_names": [],
  "last_task_name": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/tasks/next")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/next"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/next")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/tasks/next")
  .header("content-type", "application/json")
  .body("{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  worker_details: {
    worker_version: '',
    pytorch_version: '',
    system: {
      hostname: '',
      os: '',
      version: '',
      embedded_python: false
    },
    devices: [
      {
        name: '',
        type: '',
        index: 0,
        vram_total: 0,
        vram_free: 0,
        torch_vram_total: 0,
        torch_vram_free: 0
      }
    ],
    ram_total: 0,
    ram_free: 0,
    last_seen: '',
    engine_details: {
      disable_smart_memory: '',
      vram_state: '',
      cache_type: '',
      cache_size: 0,
      vae_cpu: false,
      reserve_vram: ''
    }
  },
  tasks_names: [],
  last_task_name: ''
});

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

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

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

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/tasks/next',
  headers: {'content-type': 'application/json'},
  data: {
    worker_details: {
      worker_version: '',
      pytorch_version: '',
      system: {hostname: '', os: '', version: '', embedded_python: false},
      devices: [
        {
          name: '',
          type: '',
          index: 0,
          vram_total: 0,
          vram_free: 0,
          torch_vram_total: 0,
          torch_vram_free: 0
        }
      ],
      ram_total: 0,
      ram_free: 0,
      last_seen: '',
      engine_details: {
        disable_smart_memory: '',
        vram_state: '',
        cache_type: '',
        cache_size: 0,
        vae_cpu: false,
        reserve_vram: ''
      }
    },
    tasks_names: [],
    last_task_name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/next';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"worker_details":{"worker_version":"","pytorch_version":"","system":{"hostname":"","os":"","version":"","embedded_python":false},"devices":[{"name":"","type":"","index":0,"vram_total":0,"vram_free":0,"torch_vram_total":0,"torch_vram_free":0}],"ram_total":0,"ram_free":0,"last_seen":"","engine_details":{"disable_smart_memory":"","vram_state":"","cache_type":"","cache_size":0,"vae_cpu":false,"reserve_vram":""}},"tasks_names":[],"last_task_name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/next',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "worker_details": {\n    "worker_version": "",\n    "pytorch_version": "",\n    "system": {\n      "hostname": "",\n      "os": "",\n      "version": "",\n      "embedded_python": false\n    },\n    "devices": [\n      {\n        "name": "",\n        "type": "",\n        "index": 0,\n        "vram_total": 0,\n        "vram_free": 0,\n        "torch_vram_total": 0,\n        "torch_vram_free": 0\n      }\n    ],\n    "ram_total": 0,\n    "ram_free": 0,\n    "last_seen": "",\n    "engine_details": {\n      "disable_smart_memory": "",\n      "vram_state": "",\n      "cache_type": "",\n      "cache_size": 0,\n      "vae_cpu": false,\n      "reserve_vram": ""\n    }\n  },\n  "tasks_names": [],\n  "last_task_name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/next")
  .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/vapi/tasks/next',
  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({
  worker_details: {
    worker_version: '',
    pytorch_version: '',
    system: {hostname: '', os: '', version: '', embedded_python: false},
    devices: [
      {
        name: '',
        type: '',
        index: 0,
        vram_total: 0,
        vram_free: 0,
        torch_vram_total: 0,
        torch_vram_free: 0
      }
    ],
    ram_total: 0,
    ram_free: 0,
    last_seen: '',
    engine_details: {
      disable_smart_memory: '',
      vram_state: '',
      cache_type: '',
      cache_size: 0,
      vae_cpu: false,
      reserve_vram: ''
    }
  },
  tasks_names: [],
  last_task_name: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/tasks/next',
  headers: {'content-type': 'application/json'},
  body: {
    worker_details: {
      worker_version: '',
      pytorch_version: '',
      system: {hostname: '', os: '', version: '', embedded_python: false},
      devices: [
        {
          name: '',
          type: '',
          index: 0,
          vram_total: 0,
          vram_free: 0,
          torch_vram_total: 0,
          torch_vram_free: 0
        }
      ],
      ram_total: 0,
      ram_free: 0,
      last_seen: '',
      engine_details: {
        disable_smart_memory: '',
        vram_state: '',
        cache_type: '',
        cache_size: 0,
        vae_cpu: false,
        reserve_vram: ''
      }
    },
    tasks_names: [],
    last_task_name: ''
  },
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/vapi/tasks/next');

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

req.type('json');
req.send({
  worker_details: {
    worker_version: '',
    pytorch_version: '',
    system: {
      hostname: '',
      os: '',
      version: '',
      embedded_python: false
    },
    devices: [
      {
        name: '',
        type: '',
        index: 0,
        vram_total: 0,
        vram_free: 0,
        torch_vram_total: 0,
        torch_vram_free: 0
      }
    ],
    ram_total: 0,
    ram_free: 0,
    last_seen: '',
    engine_details: {
      disable_smart_memory: '',
      vram_state: '',
      cache_type: '',
      cache_size: 0,
      vae_cpu: false,
      reserve_vram: ''
    }
  },
  tasks_names: [],
  last_task_name: ''
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/tasks/next',
  headers: {'content-type': 'application/json'},
  data: {
    worker_details: {
      worker_version: '',
      pytorch_version: '',
      system: {hostname: '', os: '', version: '', embedded_python: false},
      devices: [
        {
          name: '',
          type: '',
          index: 0,
          vram_total: 0,
          vram_free: 0,
          torch_vram_total: 0,
          torch_vram_free: 0
        }
      ],
      ram_total: 0,
      ram_free: 0,
      last_seen: '',
      engine_details: {
        disable_smart_memory: '',
        vram_state: '',
        cache_type: '',
        cache_size: 0,
        vae_cpu: false,
        reserve_vram: ''
      }
    },
    tasks_names: [],
    last_task_name: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/next';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"worker_details":{"worker_version":"","pytorch_version":"","system":{"hostname":"","os":"","version":"","embedded_python":false},"devices":[{"name":"","type":"","index":0,"vram_total":0,"vram_free":0,"torch_vram_total":0,"torch_vram_free":0}],"ram_total":0,"ram_free":0,"last_seen":"","engine_details":{"disable_smart_memory":"","vram_state":"","cache_type":"","cache_size":0,"vae_cpu":false,"reserve_vram":""}},"tasks_names":[],"last_task_name":""}'
};

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

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"worker_details": @{ @"worker_version": @"", @"pytorch_version": @"", @"system": @{ @"hostname": @"", @"os": @"", @"version": @"", @"embedded_python": @NO }, @"devices": @[ @{ @"name": @"", @"type": @"", @"index": @0, @"vram_total": @0, @"vram_free": @0, @"torch_vram_total": @0, @"torch_vram_free": @0 } ], @"ram_total": @0, @"ram_free": @0, @"last_seen": @"", @"engine_details": @{ @"disable_smart_memory": @"", @"vram_state": @"", @"cache_type": @"", @"cache_size": @0, @"vae_cpu": @NO, @"reserve_vram": @"" } },
                              @"tasks_names": @[  ],
                              @"last_task_name": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/next"]
                                                       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}}/vapi/tasks/next" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/next",
  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([
    'worker_details' => [
        'worker_version' => '',
        'pytorch_version' => '',
        'system' => [
                'hostname' => '',
                'os' => '',
                'version' => '',
                'embedded_python' => null
        ],
        'devices' => [
                [
                                'name' => '',
                                'type' => '',
                                'index' => 0,
                                'vram_total' => 0,
                                'vram_free' => 0,
                                'torch_vram_total' => 0,
                                'torch_vram_free' => 0
                ]
        ],
        'ram_total' => 0,
        'ram_free' => 0,
        'last_seen' => '',
        'engine_details' => [
                'disable_smart_memory' => '',
                'vram_state' => '',
                'cache_type' => '',
                'cache_size' => 0,
                'vae_cpu' => null,
                'reserve_vram' => ''
        ]
    ],
    'tasks_names' => [
        
    ],
    'last_task_name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/vapi/tasks/next', [
  'body' => '{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "tasks_names": [],
  "last_task_name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/next');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'worker_details' => [
    'worker_version' => '',
    'pytorch_version' => '',
    'system' => [
        'hostname' => '',
        'os' => '',
        'version' => '',
        'embedded_python' => null
    ],
    'devices' => [
        [
                'name' => '',
                'type' => '',
                'index' => 0,
                'vram_total' => 0,
                'vram_free' => 0,
                'torch_vram_total' => 0,
                'torch_vram_free' => 0
        ]
    ],
    'ram_total' => 0,
    'ram_free' => 0,
    'last_seen' => '',
    'engine_details' => [
        'disable_smart_memory' => '',
        'vram_state' => '',
        'cache_type' => '',
        'cache_size' => 0,
        'vae_cpu' => null,
        'reserve_vram' => ''
    ]
  ],
  'tasks_names' => [
    
  ],
  'last_task_name' => ''
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'worker_details' => [
    'worker_version' => '',
    'pytorch_version' => '',
    'system' => [
        'hostname' => '',
        'os' => '',
        'version' => '',
        'embedded_python' => null
    ],
    'devices' => [
        [
                'name' => '',
                'type' => '',
                'index' => 0,
                'vram_total' => 0,
                'vram_free' => 0,
                'torch_vram_total' => 0,
                'torch_vram_free' => 0
        ]
    ],
    'ram_total' => 0,
    'ram_free' => 0,
    'last_seen' => '',
    'engine_details' => [
        'disable_smart_memory' => '',
        'vram_state' => '',
        'cache_type' => '',
        'cache_size' => 0,
        'vae_cpu' => null,
        'reserve_vram' => ''
    ]
  ],
  'tasks_names' => [
    
  ],
  'last_task_name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/vapi/tasks/next');
$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}}/vapi/tasks/next' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "tasks_names": [],
  "last_task_name": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/next' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "tasks_names": [],
  "last_task_name": ""
}'
import http.client

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

payload = "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}"

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

conn.request("POST", "/baseUrl/vapi/tasks/next", payload, headers)

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

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

url = "{{baseUrl}}/vapi/tasks/next"

payload = {
    "worker_details": {
        "worker_version": "",
        "pytorch_version": "",
        "system": {
            "hostname": "",
            "os": "",
            "version": "",
            "embedded_python": False
        },
        "devices": [
            {
                "name": "",
                "type": "",
                "index": 0,
                "vram_total": 0,
                "vram_free": 0,
                "torch_vram_total": 0,
                "torch_vram_free": 0
            }
        ],
        "ram_total": 0,
        "ram_free": 0,
        "last_seen": "",
        "engine_details": {
            "disable_smart_memory": "",
            "vram_state": "",
            "cache_type": "",
            "cache_size": 0,
            "vae_cpu": False,
            "reserve_vram": ""
        }
    },
    "tasks_names": [],
    "last_task_name": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/next"

payload <- "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\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}}/vapi/tasks/next")

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  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/vapi/tasks/next') do |req|
  req.body = "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"tasks_names\": [],\n  \"last_task_name\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "worker_details": json!({
            "worker_version": "",
            "pytorch_version": "",
            "system": json!({
                "hostname": "",
                "os": "",
                "version": "",
                "embedded_python": false
            }),
            "devices": (
                json!({
                    "name": "",
                    "type": "",
                    "index": 0,
                    "vram_total": 0,
                    "vram_free": 0,
                    "torch_vram_total": 0,
                    "torch_vram_free": 0
                })
            ),
            "ram_total": 0,
            "ram_free": 0,
            "last_seen": "",
            "engine_details": json!({
                "disable_smart_memory": "",
                "vram_state": "",
                "cache_type": "",
                "cache_size": 0,
                "vae_cpu": false,
                "reserve_vram": ""
            })
        }),
        "tasks_names": (),
        "last_task_name": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/vapi/tasks/next \
  --header 'content-type: application/json' \
  --data '{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "tasks_names": [],
  "last_task_name": ""
}'
echo '{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "tasks_names": [],
  "last_task_name": ""
}' |  \
  http POST {{baseUrl}}/vapi/tasks/next \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "worker_details": {\n    "worker_version": "",\n    "pytorch_version": "",\n    "system": {\n      "hostname": "",\n      "os": "",\n      "version": "",\n      "embedded_python": false\n    },\n    "devices": [\n      {\n        "name": "",\n        "type": "",\n        "index": 0,\n        "vram_total": 0,\n        "vram_free": 0,\n        "torch_vram_total": 0,\n        "torch_vram_free": 0\n      }\n    ],\n    "ram_total": 0,\n    "ram_free": 0,\n    "last_seen": "",\n    "engine_details": {\n      "disable_smart_memory": "",\n      "vram_state": "",\n      "cache_type": "",\n      "cache_size": 0,\n      "vae_cpu": false,\n      "reserve_vram": ""\n    }\n  },\n  "tasks_names": [],\n  "last_task_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/vapi/tasks/next
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "worker_details": [
    "worker_version": "",
    "pytorch_version": "",
    "system": [
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    ],
    "devices": [
      [
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      ]
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": [
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    ]
  ],
  "tasks_names": [],
  "last_task_name": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/next")! 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 Get Task Inputs
{{baseUrl}}/vapi/tasks/inputs
QUERY PARAMS
task_id
input_index
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/tasks/inputs" {:query-params {:task_id ""
                                                                            :input_index ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index="

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}}/vapi/tasks/inputs?task_id=&input_index="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index="

	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/vapi/tasks/inputs?task_id=&input_index= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index="))
    .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}}/vapi/tasks/inputs?task_id=&input_index=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=")
  .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}}/vapi/tasks/inputs?task_id=&input_index=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/tasks/inputs',
  params: {task_id: '', input_index: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=';
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}}/vapi/tasks/inputs?task_id=&input_index=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/inputs?task_id=&input_index=',
  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}}/vapi/tasks/inputs',
  qs: {task_id: '', input_index: ''}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/tasks/inputs');

req.query({
  task_id: '',
  input_index: ''
});

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}}/vapi/tasks/inputs',
  params: {task_id: '', input_index: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=';
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}}/vapi/tasks/inputs?task_id=&input_index="]
                                                       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}}/vapi/tasks/inputs?task_id=&input_index=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=",
  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}}/vapi/tasks/inputs?task_id=&input_index=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/inputs');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'task_id' => '',
  'input_index' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/tasks/inputs');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'task_id' => '',
  'input_index' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/tasks/inputs?task_id=&input_index=")

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

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

url = "{{baseUrl}}/vapi/tasks/inputs"

querystring = {"task_id":"","input_index":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/inputs"

queryString <- list(
  task_id = "",
  input_index = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=")

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/vapi/tasks/inputs') do |req|
  req.params['task_id'] = ''
  req.params['input_index'] = ''
end

puts response.status
puts response.body
use reqwest;

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

    let querystring = [
        ("task_id", ""),
        ("input_index", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index='
http GET '{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/inputs?task_id=&input_index=")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task(task_id): input file `file_name` was not found."
}
GET Get Task Progress
{{baseUrl}}/vapi/tasks/progress/:task_id
QUERY PARAMS
task_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/progress/:task_id");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/tasks/progress/:task_id")
require "http/client"

url = "{{baseUrl}}/vapi/tasks/progress/:task_id"

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/vapi/tasks/progress/:task_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/progress/:task_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/tasks/progress/:task_id"

	req, _ := http.NewRequest("GET", url, nil)

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

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

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

}
GET /baseUrl/vapi/tasks/progress/:task_id HTTP/1.1
Host: example.com


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

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/progress/:task_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/progress/:task_id")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/tasks/progress/:task_id")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/vapi/tasks/progress/:task_id');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/tasks/progress/:task_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/progress/:task_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/progress/:task_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/progress/:task_id")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/progress/:task_id',
  headers: {}
};

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

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

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

req.end();
const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/vapi/tasks/progress/:task_id'};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/tasks/progress/:task_id');

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/vapi/tasks/progress/:task_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/progress/:task_id';
const options = {method: 'GET'};

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/progress/:task_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/tasks/progress/:task_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/progress/:task_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/vapi/tasks/progress/:task_id');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/progress/:task_id');
$request->setMethod(HTTP_METH_GET);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/tasks/progress/:task_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/progress/:task_id' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/progress/:task_id' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/vapi/tasks/progress/:task_id")

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

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

url = "{{baseUrl}}/vapi/tasks/progress/:task_id"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/progress/:task_id"

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/progress/:task_id")

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

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/vapi/tasks/progress/:task_id') do |req|
end

puts response.status
puts response.body
use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/vapi/tasks/progress/:task_id
http GET {{baseUrl}}/vapi/tasks/progress/:task_id
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/tasks/progress/:task_id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/progress/:task_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()
GET Get Task Results
{{baseUrl}}/vapi/tasks/results
QUERY PARAMS
task_id
node_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/results?task_id=&node_id=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/tasks/results" {:query-params {:task_id ""
                                                                             :node_id ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/results?task_id=&node_id="

response = HTTP::Client.get url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/vapi/tasks/results?task_id=&node_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/results?task_id=&node_id=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/vapi/tasks/results?task_id=&node_id="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
GET /baseUrl/vapi/tasks/results?task_id=&node_id= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vapi/tasks/results?task_id=&node_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/results?task_id=&node_id="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/results?task_id=&node_id=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/tasks/results?task_id=&node_id=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/vapi/tasks/results?task_id=&node_id=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/tasks/results',
  params: {task_id: '', node_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/results?task_id=&node_id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/results?task_id=&node_id=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/results?task_id=&node_id=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/results?task_id=&node_id=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/tasks/results',
  qs: {task_id: '', node_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/tasks/results');

req.query({
  task_id: '',
  node_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/tasks/results',
  params: {task_id: '', node_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/results?task_id=&node_id=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/results?task_id=&node_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/tasks/results?task_id=&node_id=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/results?task_id=&node_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/vapi/tasks/results?task_id=&node_id=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/results');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'task_id' => '',
  'node_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/tasks/results');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'task_id' => '',
  'node_id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/results?task_id=&node_id=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/results?task_id=&node_id=' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/vapi/tasks/results?task_id=&node_id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/tasks/results"

querystring = {"task_id":"","node_id":""}

response = requests.get(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/results"

queryString <- list(
  task_id = "",
  node_id = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/results?task_id=&node_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/vapi/tasks/results') do |req|
  req.params['task_id'] = ''
  req.params['node_id'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/tasks/results";

    let querystring = [
        ("task_id", ""),
        ("node_id", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/vapi/tasks/results?task_id=&node_id='
http GET '{{baseUrl}}/vapi/tasks/results?task_id=&node_id='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/vapi/tasks/results?task_id=&node_id='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/results?task_id=&node_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task `task_id` is not completed yet."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Missing result for task=`task_id` and node=`node_id`."
}
GET Get Tasks Progress Summary
{{baseUrl}}/vapi/tasks/progress-summary
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/progress-summary");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/tasks/progress-summary")
require "http/client"

url = "{{baseUrl}}/vapi/tasks/progress-summary"

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}}/vapi/tasks/progress-summary"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/progress-summary");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/tasks/progress-summary"

	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/vapi/tasks/progress-summary HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vapi/tasks/progress-summary")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/progress-summary"))
    .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}}/vapi/tasks/progress-summary")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/tasks/progress-summary")
  .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}}/vapi/tasks/progress-summary');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/tasks/progress-summary'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/progress-summary';
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}}/vapi/tasks/progress-summary',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/progress-summary")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/progress-summary',
  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}}/vapi/tasks/progress-summary'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/tasks/progress-summary');

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}}/vapi/tasks/progress-summary'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/progress-summary';
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}}/vapi/tasks/progress-summary"]
                                                       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}}/vapi/tasks/progress-summary" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/progress-summary",
  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}}/vapi/tasks/progress-summary');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/progress-summary');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/tasks/progress-summary');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/progress-summary' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/progress-summary' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/vapi/tasks/progress-summary")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/tasks/progress-summary"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/progress-summary"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/progress-summary")

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/vapi/tasks/progress-summary') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/tasks/progress-summary";

    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}}/vapi/tasks/progress-summary
http GET {{baseUrl}}/vapi/tasks/progress-summary
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/tasks/progress-summary
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/progress-summary")! 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 Get Tasks Progress
{{baseUrl}}/vapi/tasks/progress
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/progress");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/tasks/progress")
require "http/client"

url = "{{baseUrl}}/vapi/tasks/progress"

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}}/vapi/tasks/progress"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/progress");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/tasks/progress"

	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/vapi/tasks/progress HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vapi/tasks/progress")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/progress"))
    .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}}/vapi/tasks/progress")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/tasks/progress")
  .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}}/vapi/tasks/progress');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/tasks/progress'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/progress';
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}}/vapi/tasks/progress',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/progress")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/progress',
  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}}/vapi/tasks/progress'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/tasks/progress');

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}}/vapi/tasks/progress'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/progress';
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}}/vapi/tasks/progress"]
                                                       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}}/vapi/tasks/progress" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/progress",
  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}}/vapi/tasks/progress');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/progress');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/tasks/progress');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/progress' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/progress' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/vapi/tasks/progress")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/tasks/progress"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/progress"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/progress")

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/vapi/tasks/progress') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/tasks/progress";

    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}}/vapi/tasks/progress
http GET {{baseUrl}}/vapi/tasks/progress
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/tasks/progress
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/progress")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
DELETE Remove Task From Queue
{{baseUrl}}/vapi/tasks/queue/:task_id
QUERY PARAMS
task_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/queue/:task_id");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/vapi/tasks/queue/:task_id")
require "http/client"

url = "{{baseUrl}}/vapi/tasks/queue/:task_id"

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/vapi/tasks/queue/:task_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/queue/:task_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/tasks/queue/:task_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
DELETE /baseUrl/vapi/tasks/queue/:task_id HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/vapi/tasks/queue/:task_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/queue/:task_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/queue/:task_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/vapi/tasks/queue/:task_id")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/vapi/tasks/queue/:task_id');

xhr.send(data);
import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/vapi/tasks/queue/:task_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/queue/:task_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/queue/:task_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/queue/:task_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/queue/:task_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/vapi/tasks/queue/:task_id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/vapi/tasks/queue/:task_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/vapi/tasks/queue/:task_id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/queue/:task_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/queue/:task_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/tasks/queue/:task_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/queue/:task_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/vapi/tasks/queue/:task_id');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/queue/:task_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/tasks/queue/:task_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/queue/:task_id' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/queue/:task_id' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/vapi/tasks/queue/:task_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/tasks/queue/:task_id"

response = requests.delete(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/queue/:task_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/queue/:task_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/vapi/tasks/queue/:task_id') do |req|
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/tasks/queue/:task_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/vapi/tasks/queue/:task_id
http DELETE {{baseUrl}}/vapi/tasks/queue/:task_id
wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/vapi/tasks/queue/:task_id
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/queue/:task_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task `{task_id}` was not found."
}
DELETE Remove Task Lock
{{baseUrl}}/vapi/tasks/lock
QUERY PARAMS
task_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/lock?task_id=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/vapi/tasks/lock" {:query-params {:task_id ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/lock?task_id="

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/vapi/tasks/lock?task_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/lock?task_id=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/tasks/lock?task_id="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
DELETE /baseUrl/vapi/tasks/lock?task_id= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/vapi/tasks/lock?task_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/lock?task_id="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/lock?task_id=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/vapi/tasks/lock?task_id=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/vapi/tasks/lock?task_id=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/lock',
  params: {task_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/lock?task_id=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/lock?task_id=',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/lock?task_id=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/lock?task_id=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/lock',
  qs: {task_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/vapi/tasks/lock');

req.query({
  task_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/lock',
  params: {task_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/lock?task_id=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/lock?task_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/tasks/lock?task_id=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/lock?task_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/vapi/tasks/lock?task_id=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/lock');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'task_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/tasks/lock');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'task_id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/lock?task_id=' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/lock?task_id=' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/vapi/tasks/lock?task_id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/tasks/lock"

querystring = {"task_id":""}

response = requests.delete(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/lock"

queryString <- list(task_id = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/lock?task_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/vapi/tasks/lock') do |req|
  req.params['task_id'] = ''
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/tasks/lock";

    let querystring = [
        ("task_id", ""),
    ];

    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}}/vapi/tasks/lock?task_id='
http DELETE '{{baseUrl}}/vapi/tasks/lock?task_id='
wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/vapi/tasks/lock?task_id='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/lock?task_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task `{task_id}` was not found."
}
DELETE Remove Tasks From Queue
{{baseUrl}}/vapi/tasks/queue
QUERY PARAMS
name
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/queue?name=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/vapi/tasks/queue" {:query-params {:name ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/queue?name="

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/vapi/tasks/queue?name="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/queue?name=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/tasks/queue?name="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
DELETE /baseUrl/vapi/tasks/queue?name= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/vapi/tasks/queue?name=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/queue?name="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/queue?name=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/vapi/tasks/queue?name=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/vapi/tasks/queue?name=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/queue',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/queue?name=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/queue?name=',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/queue?name=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/queue?name=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/queue',
  qs: {name: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/vapi/tasks/queue');

req.query({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/tasks/queue',
  params: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/queue?name=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/queue?name="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/tasks/queue?name=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/queue?name=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/vapi/tasks/queue?name=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/queue');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'name' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/tasks/queue');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'name' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/queue?name=' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/queue?name=' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/vapi/tasks/queue?name=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/tasks/queue"

querystring = {"name":""}

response = requests.delete(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/queue"

queryString <- list(name = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/queue?name=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/vapi/tasks/queue') do |req|
  req.params['name'] = ''
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/tasks/queue";

    let querystring = [
        ("name", ""),
    ];

    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}}/vapi/tasks/queue?name='
http DELETE '{{baseUrl}}/vapi/tasks/queue?name='
wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/vapi/tasks/queue?name='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/queue?name=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
POST Restart Task
{{baseUrl}}/vapi/tasks/restart
QUERY PARAMS
task_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/restart?task_id=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/tasks/restart" {:query-params {:task_id ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/restart?task_id="

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}}/vapi/tasks/restart?task_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/restart?task_id=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/tasks/restart?task_id="

	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/vapi/tasks/restart?task_id= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/tasks/restart?task_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/restart?task_id="))
    .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}}/vapi/tasks/restart?task_id=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/tasks/restart?task_id=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/vapi/tasks/restart?task_id=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/tasks/restart',
  params: {task_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/restart?task_id=';
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}}/vapi/tasks/restart?task_id=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/restart?task_id=")
  .post(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/restart?task_id=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/tasks/restart',
  qs: {task_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/vapi/tasks/restart');

req.query({
  task_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/tasks/restart',
  params: {task_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/restart?task_id=';
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}}/vapi/tasks/restart?task_id="]
                                                       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}}/vapi/tasks/restart?task_id=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/restart?task_id=",
  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}}/vapi/tasks/restart?task_id=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/restart');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'task_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/tasks/restart');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'task_id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/restart?task_id=' -Method POST 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/restart?task_id=' -Method POST 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/vapi/tasks/restart?task_id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/tasks/restart"

querystring = {"task_id":""}

response = requests.post(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/restart"

queryString <- list(task_id = "")

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/restart?task_id=")

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/vapi/tasks/restart') do |req|
  req.params['task_id'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/tasks/restart";

    let querystring = [
        ("task_id", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/vapi/tasks/restart?task_id='
http POST '{{baseUrl}}/vapi/tasks/restart?task_id='
wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/vapi/tasks/restart?task_id='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/restart?task_id=")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task `{task_id}` already finished."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task `{task_id}` has no error set."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task `{task_id}` was not found."
}
PUT Set Task Results
{{baseUrl}}/vapi/tasks/results
QUERY PARAMS
task_id
BODY formUrlEncoded
files
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/results?task_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "files=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/vapi/tasks/results" {:query-params {:task_id ""}
                                                              :form-params {:files ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/results?task_id="
headers = HTTP::Headers{
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "files="

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}}/vapi/tasks/results?task_id="),
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "files", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/tasks/results?task_id=");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "files=", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/tasks/results?task_id="

	payload := strings.NewReader("files=")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
PUT /baseUrl/vapi/tasks/results?task_id= HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 6

files=
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/vapi/tasks/results?task_id=")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("files=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/results?task_id="))
    .header("content-type", "application/x-www-form-urlencoded")
    .method("PUT", HttpRequest.BodyPublishers.ofString("files="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "files=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/results?task_id=")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/vapi/tasks/results?task_id=")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("files=")
  .asString();
const data = 'files=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/vapi/tasks/results?task_id=');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);
import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('files', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/results',
  params: {task_id: ''},
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/results?task_id=';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({files: ''})
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/results?task_id=',
  method: 'PUT',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    files: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "files=")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/results?task_id=")
  .put(body)
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

val response = client.newCall(request).execute()
const qs = require('querystring');
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/results?task_id=',
  headers: {
    'content-type': 'application/x-www-form-urlencoded'
  }
};

const req = http.request(options, function (res) {
  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(qs.stringify({files: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/results',
  qs: {task_id: ''},
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  form: {files: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/vapi/tasks/results');

req.query({
  task_id: ''
});

req.headers({
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  files: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('files', '');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/results',
  params: {task_id: ''},
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('files', '');

const url = '{{baseUrl}}/vapi/tasks/results?task_id=';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"files=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/results?task_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/tasks/results?task_id=" in
let headers = Header.add (Header.init ()) "content-type" "application/x-www-form-urlencoded" in
let body = Cohttp_lwt_body.of_string "files=" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/results?task_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => "files=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/vapi/tasks/results?task_id=', [
  'form_params' => [
    'files' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/results');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'task_id' => ''
]);

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'files' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(new http\QueryString([
  'files' => ''
]));

$request->setRequestUrl('{{baseUrl}}/vapi/tasks/results');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'task_id' => ''
]));

$request->setHeaders([
  'content-type' => 'application/x-www-form-urlencoded'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/tasks/results?task_id=' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'files='
$headers=@{}
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/results?task_id=' -Method PUT -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'files='
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "files="

headers = { 'content-type': "application/x-www-form-urlencoded" }

conn.request("PUT", "/baseUrl/vapi/tasks/results?task_id=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/tasks/results"

querystring = {"task_id":""}

payload = { "files": "" }
headers = {"content-type": "application/x-www-form-urlencoded"}

response = requests.put(url, data=payload, headers=headers, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/results"

queryString <- list(task_id = "")

payload <- "files="

encode <- "form"

response <- VERB("PUT", url, body = payload, query = queryString, content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/results?task_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "files="

response = http.request(request)
puts response.read_body
require 'faraday'

data = {
  :files => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.put('/baseUrl/vapi/tasks/results') do |req|
  req.params['task_id'] = ''
  req.body = URI.encode_www_form(data)
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}}/vapi/tasks/results";

    let querystring = [
        ("task_id", ""),
    ];

    let payload = json!({"files": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/vapi/tasks/results?task_id=' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --data files=
http --form PUT '{{baseUrl}}/vapi/tasks/results?task_id=' \
  content-type:application/x-www-form-urlencoded \
  files=''
wget --quiet \
  --method PUT \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data files= \
  --output-document \
  - '{{baseUrl}}/vapi/tasks/results?task_id='
import Foundation

let headers = ["content-type": "application/x-www-form-urlencoded"]

let postData = NSMutableData(data: "files=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/results?task_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "result_file.filename does not belong to task."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task `{task_id}` was not found."
}
PUT Update Task Info
{{baseUrl}}/vapi/tasks/update
QUERY PARAMS
task_id
BODY json
{
  "priority": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/update?task_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"priority\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/vapi/tasks/update" {:query-params {:task_id ""}
                                                             :content-type :json
                                                             :form-params {:priority ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/update?task_id="
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"priority\": \"\"\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}}/vapi/tasks/update?task_id="),
    Content = new StringContent("{\n  \"priority\": \"\"\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}}/vapi/tasks/update?task_id=");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"priority\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/tasks/update?task_id="

	payload := strings.NewReader("{\n  \"priority\": \"\"\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/vapi/tasks/update?task_id= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "priority": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/vapi/tasks/update?task_id=")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"priority\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/update?task_id="))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"priority\": \"\"\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  \"priority\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/update?task_id=")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/vapi/tasks/update?task_id=")
  .header("content-type", "application/json")
  .body("{\n  \"priority\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  priority: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/vapi/tasks/update?task_id=');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/update',
  params: {task_id: ''},
  headers: {'content-type': 'application/json'},
  data: {priority: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/update?task_id=';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"priority":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/update?task_id=',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "priority": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"priority\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/update?task_id=")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/tasks/update?task_id=',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({priority: ''}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/update',
  qs: {task_id: ''},
  headers: {'content-type': 'application/json'},
  body: {priority: ''},
  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}}/vapi/tasks/update');

req.query({
  task_id: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  priority: ''
});

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}}/vapi/tasks/update',
  params: {task_id: ''},
  headers: {'content-type': 'application/json'},
  data: {priority: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/update?task_id=';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"priority":""}'
};

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 = @{ @"priority": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/update?task_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/tasks/update?task_id=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"priority\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/update?task_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'priority' => ''
  ]),
  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}}/vapi/tasks/update?task_id=', [
  'body' => '{
  "priority": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/update');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'task_id' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'priority' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'priority' => ''
]));
$request->setRequestUrl('{{baseUrl}}/vapi/tasks/update');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'task_id' => ''
]));

$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}}/vapi/tasks/update?task_id=' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "priority": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/update?task_id=' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "priority": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"priority\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/vapi/tasks/update?task_id=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/tasks/update"

querystring = {"task_id":""}

payload = { "priority": "" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/update"

queryString <- list(task_id = "")

payload <- "{\n  \"priority\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/tasks/update?task_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"priority\": \"\"\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/vapi/tasks/update') do |req|
  req.params['task_id'] = ''
  req.body = "{\n  \"priority\": \"\"\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}}/vapi/tasks/update";

    let querystring = [
        ("task_id", ""),
    ];

    let payload = json!({"priority": ""});

    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)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/vapi/tasks/update?task_id=' \
  --header 'content-type: application/json' \
  --data '{
  "priority": ""
}'
echo '{
  "priority": ""
}' |  \
  http PUT '{{baseUrl}}/vapi/tasks/update?task_id=' \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "priority": ""\n}' \
  --output-document \
  - '{{baseUrl}}/vapi/tasks/update?task_id='
import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["priority": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/update?task_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task `{task_id}` cannot be updated because it has already started."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Priority cannot be greater than 15."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "No valid fields to update."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task `{task_id}` was not found."
}
PUT Update Task Progress
{{baseUrl}}/vapi/tasks/progress
BODY json
{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "task_id": 0,
  "progress": "",
  "execution_time": "",
  "error": "",
  "execution_details": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/tasks/progress");

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  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/vapi/tasks/progress" {:content-type :json
                                                               :form-params {:worker_details {:worker_version ""
                                                                                              :pytorch_version ""
                                                                                              :system {:hostname ""
                                                                                                       :os ""
                                                                                                       :version ""
                                                                                                       :embedded_python false}
                                                                                              :devices [{:name ""
                                                                                                         :type ""
                                                                                                         :index 0
                                                                                                         :vram_total 0
                                                                                                         :vram_free 0
                                                                                                         :torch_vram_total 0
                                                                                                         :torch_vram_free 0}]
                                                                                              :ram_total 0
                                                                                              :ram_free 0
                                                                                              :last_seen ""
                                                                                              :engine_details {:disable_smart_memory ""
                                                                                                               :vram_state ""
                                                                                                               :cache_type ""
                                                                                                               :cache_size 0
                                                                                                               :vae_cpu false
                                                                                                               :reserve_vram ""}}
                                                                             :task_id 0
                                                                             :progress ""
                                                                             :execution_time ""
                                                                             :error ""
                                                                             :execution_details ""}})
require "http/client"

url = "{{baseUrl}}/vapi/tasks/progress"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\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}}/vapi/tasks/progress"),
    Content = new StringContent("{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\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}}/vapi/tasks/progress");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/tasks/progress"

	payload := strings.NewReader("{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\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/vapi/tasks/progress HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 748

{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "task_id": 0,
  "progress": "",
  "execution_time": "",
  "error": "",
  "execution_details": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/vapi/tasks/progress")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/tasks/progress"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\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  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/progress")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/vapi/tasks/progress")
  .header("content-type", "application/json")
  .body("{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  worker_details: {
    worker_version: '',
    pytorch_version: '',
    system: {
      hostname: '',
      os: '',
      version: '',
      embedded_python: false
    },
    devices: [
      {
        name: '',
        type: '',
        index: 0,
        vram_total: 0,
        vram_free: 0,
        torch_vram_total: 0,
        torch_vram_free: 0
      }
    ],
    ram_total: 0,
    ram_free: 0,
    last_seen: '',
    engine_details: {
      disable_smart_memory: '',
      vram_state: '',
      cache_type: '',
      cache_size: 0,
      vae_cpu: false,
      reserve_vram: ''
    }
  },
  task_id: 0,
  progress: '',
  execution_time: '',
  error: '',
  execution_details: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/vapi/tasks/progress');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/progress',
  headers: {'content-type': 'application/json'},
  data: {
    worker_details: {
      worker_version: '',
      pytorch_version: '',
      system: {hostname: '', os: '', version: '', embedded_python: false},
      devices: [
        {
          name: '',
          type: '',
          index: 0,
          vram_total: 0,
          vram_free: 0,
          torch_vram_total: 0,
          torch_vram_free: 0
        }
      ],
      ram_total: 0,
      ram_free: 0,
      last_seen: '',
      engine_details: {
        disable_smart_memory: '',
        vram_state: '',
        cache_type: '',
        cache_size: 0,
        vae_cpu: false,
        reserve_vram: ''
      }
    },
    task_id: 0,
    progress: '',
    execution_time: '',
    error: '',
    execution_details: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/tasks/progress';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"worker_details":{"worker_version":"","pytorch_version":"","system":{"hostname":"","os":"","version":"","embedded_python":false},"devices":[{"name":"","type":"","index":0,"vram_total":0,"vram_free":0,"torch_vram_total":0,"torch_vram_free":0}],"ram_total":0,"ram_free":0,"last_seen":"","engine_details":{"disable_smart_memory":"","vram_state":"","cache_type":"","cache_size":0,"vae_cpu":false,"reserve_vram":""}},"task_id":0,"progress":"","execution_time":"","error":"","execution_details":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/tasks/progress',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "worker_details": {\n    "worker_version": "",\n    "pytorch_version": "",\n    "system": {\n      "hostname": "",\n      "os": "",\n      "version": "",\n      "embedded_python": false\n    },\n    "devices": [\n      {\n        "name": "",\n        "type": "",\n        "index": 0,\n        "vram_total": 0,\n        "vram_free": 0,\n        "torch_vram_total": 0,\n        "torch_vram_free": 0\n      }\n    ],\n    "ram_total": 0,\n    "ram_free": 0,\n    "last_seen": "",\n    "engine_details": {\n      "disable_smart_memory": "",\n      "vram_state": "",\n      "cache_type": "",\n      "cache_size": 0,\n      "vae_cpu": false,\n      "reserve_vram": ""\n    }\n  },\n  "task_id": 0,\n  "progress": "",\n  "execution_time": "",\n  "error": "",\n  "execution_details": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/tasks/progress")
  .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/vapi/tasks/progress',
  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({
  worker_details: {
    worker_version: '',
    pytorch_version: '',
    system: {hostname: '', os: '', version: '', embedded_python: false},
    devices: [
      {
        name: '',
        type: '',
        index: 0,
        vram_total: 0,
        vram_free: 0,
        torch_vram_total: 0,
        torch_vram_free: 0
      }
    ],
    ram_total: 0,
    ram_free: 0,
    last_seen: '',
    engine_details: {
      disable_smart_memory: '',
      vram_state: '',
      cache_type: '',
      cache_size: 0,
      vae_cpu: false,
      reserve_vram: ''
    }
  },
  task_id: 0,
  progress: '',
  execution_time: '',
  error: '',
  execution_details: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/progress',
  headers: {'content-type': 'application/json'},
  body: {
    worker_details: {
      worker_version: '',
      pytorch_version: '',
      system: {hostname: '', os: '', version: '', embedded_python: false},
      devices: [
        {
          name: '',
          type: '',
          index: 0,
          vram_total: 0,
          vram_free: 0,
          torch_vram_total: 0,
          torch_vram_free: 0
        }
      ],
      ram_total: 0,
      ram_free: 0,
      last_seen: '',
      engine_details: {
        disable_smart_memory: '',
        vram_state: '',
        cache_type: '',
        cache_size: 0,
        vae_cpu: false,
        reserve_vram: ''
      }
    },
    task_id: 0,
    progress: '',
    execution_time: '',
    error: '',
    execution_details: ''
  },
  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}}/vapi/tasks/progress');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  worker_details: {
    worker_version: '',
    pytorch_version: '',
    system: {
      hostname: '',
      os: '',
      version: '',
      embedded_python: false
    },
    devices: [
      {
        name: '',
        type: '',
        index: 0,
        vram_total: 0,
        vram_free: 0,
        torch_vram_total: 0,
        torch_vram_free: 0
      }
    ],
    ram_total: 0,
    ram_free: 0,
    last_seen: '',
    engine_details: {
      disable_smart_memory: '',
      vram_state: '',
      cache_type: '',
      cache_size: 0,
      vae_cpu: false,
      reserve_vram: ''
    }
  },
  task_id: 0,
  progress: '',
  execution_time: '',
  error: '',
  execution_details: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/vapi/tasks/progress',
  headers: {'content-type': 'application/json'},
  data: {
    worker_details: {
      worker_version: '',
      pytorch_version: '',
      system: {hostname: '', os: '', version: '', embedded_python: false},
      devices: [
        {
          name: '',
          type: '',
          index: 0,
          vram_total: 0,
          vram_free: 0,
          torch_vram_total: 0,
          torch_vram_free: 0
        }
      ],
      ram_total: 0,
      ram_free: 0,
      last_seen: '',
      engine_details: {
        disable_smart_memory: '',
        vram_state: '',
        cache_type: '',
        cache_size: 0,
        vae_cpu: false,
        reserve_vram: ''
      }
    },
    task_id: 0,
    progress: '',
    execution_time: '',
    error: '',
    execution_details: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/tasks/progress';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"worker_details":{"worker_version":"","pytorch_version":"","system":{"hostname":"","os":"","version":"","embedded_python":false},"devices":[{"name":"","type":"","index":0,"vram_total":0,"vram_free":0,"torch_vram_total":0,"torch_vram_free":0}],"ram_total":0,"ram_free":0,"last_seen":"","engine_details":{"disable_smart_memory":"","vram_state":"","cache_type":"","cache_size":0,"vae_cpu":false,"reserve_vram":""}},"task_id":0,"progress":"","execution_time":"","error":"","execution_details":""}'
};

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 = @{ @"worker_details": @{ @"worker_version": @"", @"pytorch_version": @"", @"system": @{ @"hostname": @"", @"os": @"", @"version": @"", @"embedded_python": @NO }, @"devices": @[ @{ @"name": @"", @"type": @"", @"index": @0, @"vram_total": @0, @"vram_free": @0, @"torch_vram_total": @0, @"torch_vram_free": @0 } ], @"ram_total": @0, @"ram_free": @0, @"last_seen": @"", @"engine_details": @{ @"disable_smart_memory": @"", @"vram_state": @"", @"cache_type": @"", @"cache_size": @0, @"vae_cpu": @NO, @"reserve_vram": @"" } },
                              @"task_id": @0,
                              @"progress": @"",
                              @"execution_time": @"",
                              @"error": @"",
                              @"execution_details": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/tasks/progress"]
                                                       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}}/vapi/tasks/progress" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/tasks/progress",
  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([
    'worker_details' => [
        'worker_version' => '',
        'pytorch_version' => '',
        'system' => [
                'hostname' => '',
                'os' => '',
                'version' => '',
                'embedded_python' => null
        ],
        'devices' => [
                [
                                'name' => '',
                                'type' => '',
                                'index' => 0,
                                'vram_total' => 0,
                                'vram_free' => 0,
                                'torch_vram_total' => 0,
                                'torch_vram_free' => 0
                ]
        ],
        'ram_total' => 0,
        'ram_free' => 0,
        'last_seen' => '',
        'engine_details' => [
                'disable_smart_memory' => '',
                'vram_state' => '',
                'cache_type' => '',
                'cache_size' => 0,
                'vae_cpu' => null,
                'reserve_vram' => ''
        ]
    ],
    'task_id' => 0,
    'progress' => '',
    'execution_time' => '',
    'error' => '',
    'execution_details' => ''
  ]),
  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}}/vapi/tasks/progress', [
  'body' => '{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "task_id": 0,
  "progress": "",
  "execution_time": "",
  "error": "",
  "execution_details": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/tasks/progress');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'worker_details' => [
    'worker_version' => '',
    'pytorch_version' => '',
    'system' => [
        'hostname' => '',
        'os' => '',
        'version' => '',
        'embedded_python' => null
    ],
    'devices' => [
        [
                'name' => '',
                'type' => '',
                'index' => 0,
                'vram_total' => 0,
                'vram_free' => 0,
                'torch_vram_total' => 0,
                'torch_vram_free' => 0
        ]
    ],
    'ram_total' => 0,
    'ram_free' => 0,
    'last_seen' => '',
    'engine_details' => [
        'disable_smart_memory' => '',
        'vram_state' => '',
        'cache_type' => '',
        'cache_size' => 0,
        'vae_cpu' => null,
        'reserve_vram' => ''
    ]
  ],
  'task_id' => 0,
  'progress' => '',
  'execution_time' => '',
  'error' => '',
  'execution_details' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'worker_details' => [
    'worker_version' => '',
    'pytorch_version' => '',
    'system' => [
        'hostname' => '',
        'os' => '',
        'version' => '',
        'embedded_python' => null
    ],
    'devices' => [
        [
                'name' => '',
                'type' => '',
                'index' => 0,
                'vram_total' => 0,
                'vram_free' => 0,
                'torch_vram_total' => 0,
                'torch_vram_free' => 0
        ]
    ],
    'ram_total' => 0,
    'ram_free' => 0,
    'last_seen' => '',
    'engine_details' => [
        'disable_smart_memory' => '',
        'vram_state' => '',
        'cache_type' => '',
        'cache_size' => 0,
        'vae_cpu' => null,
        'reserve_vram' => ''
    ]
  ],
  'task_id' => 0,
  'progress' => '',
  'execution_time' => '',
  'error' => '',
  'execution_details' => ''
]));
$request->setRequestUrl('{{baseUrl}}/vapi/tasks/progress');
$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}}/vapi/tasks/progress' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "task_id": 0,
  "progress": "",
  "execution_time": "",
  "error": "",
  "execution_details": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/tasks/progress' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "task_id": 0,
  "progress": "",
  "execution_time": "",
  "error": "",
  "execution_details": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/vapi/tasks/progress", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/tasks/progress"

payload = {
    "worker_details": {
        "worker_version": "",
        "pytorch_version": "",
        "system": {
            "hostname": "",
            "os": "",
            "version": "",
            "embedded_python": False
        },
        "devices": [
            {
                "name": "",
                "type": "",
                "index": 0,
                "vram_total": 0,
                "vram_free": 0,
                "torch_vram_total": 0,
                "torch_vram_free": 0
            }
        ],
        "ram_total": 0,
        "ram_free": 0,
        "last_seen": "",
        "engine_details": {
            "disable_smart_memory": "",
            "vram_state": "",
            "cache_type": "",
            "cache_size": 0,
            "vae_cpu": False,
            "reserve_vram": ""
        }
    },
    "task_id": 0,
    "progress": "",
    "execution_time": "",
    "error": "",
    "execution_details": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/tasks/progress"

payload <- "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\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}}/vapi/tasks/progress")

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  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\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/vapi/tasks/progress') do |req|
  req.body = "{\n  \"worker_details\": {\n    \"worker_version\": \"\",\n    \"pytorch_version\": \"\",\n    \"system\": {\n      \"hostname\": \"\",\n      \"os\": \"\",\n      \"version\": \"\",\n      \"embedded_python\": false\n    },\n    \"devices\": [\n      {\n        \"name\": \"\",\n        \"type\": \"\",\n        \"index\": 0,\n        \"vram_total\": 0,\n        \"vram_free\": 0,\n        \"torch_vram_total\": 0,\n        \"torch_vram_free\": 0\n      }\n    ],\n    \"ram_total\": 0,\n    \"ram_free\": 0,\n    \"last_seen\": \"\",\n    \"engine_details\": {\n      \"disable_smart_memory\": \"\",\n      \"vram_state\": \"\",\n      \"cache_type\": \"\",\n      \"cache_size\": 0,\n      \"vae_cpu\": false,\n      \"reserve_vram\": \"\"\n    }\n  },\n  \"task_id\": 0,\n  \"progress\": \"\",\n  \"execution_time\": \"\",\n  \"error\": \"\",\n  \"execution_details\": \"\"\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}}/vapi/tasks/progress";

    let payload = json!({
        "worker_details": json!({
            "worker_version": "",
            "pytorch_version": "",
            "system": json!({
                "hostname": "",
                "os": "",
                "version": "",
                "embedded_python": false
            }),
            "devices": (
                json!({
                    "name": "",
                    "type": "",
                    "index": 0,
                    "vram_total": 0,
                    "vram_free": 0,
                    "torch_vram_total": 0,
                    "torch_vram_free": 0
                })
            ),
            "ram_total": 0,
            "ram_free": 0,
            "last_seen": "",
            "engine_details": json!({
                "disable_smart_memory": "",
                "vram_state": "",
                "cache_type": "",
                "cache_size": 0,
                "vae_cpu": false,
                "reserve_vram": ""
            })
        }),
        "task_id": 0,
        "progress": "",
        "execution_time": "",
        "error": "",
        "execution_details": ""
    });

    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}}/vapi/tasks/progress \
  --header 'content-type: application/json' \
  --data '{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "task_id": 0,
  "progress": "",
  "execution_time": "",
  "error": "",
  "execution_details": ""
}'
echo '{
  "worker_details": {
    "worker_version": "",
    "pytorch_version": "",
    "system": {
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    },
    "devices": [
      {
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      }
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": {
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    }
  },
  "task_id": 0,
  "progress": "",
  "execution_time": "",
  "error": "",
  "execution_details": ""
}' |  \
  http PUT {{baseUrl}}/vapi/tasks/progress \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "worker_details": {\n    "worker_version": "",\n    "pytorch_version": "",\n    "system": {\n      "hostname": "",\n      "os": "",\n      "version": "",\n      "embedded_python": false\n    },\n    "devices": [\n      {\n        "name": "",\n        "type": "",\n        "index": 0,\n        "vram_total": 0,\n        "vram_free": 0,\n        "torch_vram_total": 0,\n        "torch_vram_free": 0\n      }\n    ],\n    "ram_total": 0,\n    "ram_free": 0,\n    "last_seen": "",\n    "engine_details": {\n      "disable_smart_memory": "",\n      "vram_state": "",\n      "cache_type": "",\n      "cache_size": 0,\n      "vae_cpu": false,\n      "reserve_vram": ""\n    }\n  },\n  "task_id": 0,\n  "progress": "",\n  "execution_time": "",\n  "error": "",\n  "execution_details": ""\n}' \
  --output-document \
  - {{baseUrl}}/vapi/tasks/progress
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "worker_details": [
    "worker_version": "",
    "pytorch_version": "",
    "system": [
      "hostname": "",
      "os": "",
      "version": "",
      "embedded_python": false
    ],
    "devices": [
      [
        "name": "",
        "type": "",
        "index": 0,
        "vram_total": 0,
        "vram_free": 0,
        "torch_vram_total": 0,
        "torch_vram_free": 0
      ]
    ],
    "ram_total": 0,
    "ram_free": 0,
    "last_seen": "",
    "engine_details": [
      "disable_smart_memory": "",
      "vram_state": "",
      "cache_type": "",
      "cache_size": 0,
      "vae_cpu": false,
      "reserve_vram": ""
    ]
  ],
  "task_id": 0,
  "progress": "",
  "execution_time": "",
  "error": "",
  "execution_details": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/tasks/progress")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Failed to update task progress."
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Task `{task_id}` was not found."
}
GET Default Engine Settings
{{baseUrl}}/vapi/workers/default_engine_settings
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/workers/default_engine_settings");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/workers/default_engine_settings")
require "http/client"

url = "{{baseUrl}}/vapi/workers/default_engine_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}}/vapi/workers/default_engine_settings"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/workers/default_engine_settings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/workers/default_engine_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/vapi/workers/default_engine_settings HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vapi/workers/default_engine_settings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/workers/default_engine_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}}/vapi/workers/default_engine_settings")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/workers/default_engine_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}}/vapi/workers/default_engine_settings');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/vapi/workers/default_engine_settings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/workers/default_engine_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}}/vapi/workers/default_engine_settings',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/workers/default_engine_settings")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/workers/default_engine_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}}/vapi/workers/default_engine_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}}/vapi/workers/default_engine_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}}/vapi/workers/default_engine_settings'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/workers/default_engine_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}}/vapi/workers/default_engine_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}}/vapi/workers/default_engine_settings" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/workers/default_engine_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}}/vapi/workers/default_engine_settings');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/workers/default_engine_settings');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/workers/default_engine_settings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/workers/default_engine_settings' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/workers/default_engine_settings' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/vapi/workers/default_engine_settings")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/workers/default_engine_settings"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/workers/default_engine_settings"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/workers/default_engine_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/vapi/workers/default_engine_settings') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/workers/default_engine_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}}/vapi/workers/default_engine_settings
http GET {{baseUrl}}/vapi/workers/default_engine_settings
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/workers/default_engine_settings
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/workers/default_engine_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()
DELETE Delete Workers
{{baseUrl}}/vapi/workers
QUERY PARAMS
worker_id
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/workers?worker_id=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/vapi/workers" {:query-params {:worker_id ""}})
require "http/client"

url = "{{baseUrl}}/vapi/workers?worker_id="

response = HTTP::Client.delete url
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/vapi/workers?worker_id="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/workers?worker_id=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/workers?worker_id="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
DELETE /baseUrl/vapi/workers?worker_id= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/vapi/workers?worker_id=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/workers?worker_id="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/workers?worker_id=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/vapi/workers?worker_id=")
  .asString();
const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/vapi/workers?worker_id=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/workers',
  params: {worker_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/workers?worker_id=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/workers?worker_id=',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/workers?worker_id=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/workers?worker_id=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();
const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/workers',
  qs: {worker_id: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/vapi/workers');

req.query({
  worker_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/vapi/workers',
  params: {worker_id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/workers?worker_id=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/workers?worker_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/vapi/workers?worker_id=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/workers?worker_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/vapi/workers?worker_id=');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/workers');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'worker_id' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/workers');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'worker_id' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/workers?worker_id=' -Method DELETE 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/workers?worker_id=' -Method DELETE 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/vapi/workers?worker_id=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/workers"

querystring = {"worker_id":""}

response = requests.delete(url, params=querystring)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/workers"

queryString <- list(worker_id = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/workers?worker_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/vapi/workers') do |req|
  req.params['worker_id'] = ''
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/workers";

    let querystring = [
        ("worker_id", ""),
    ];

    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}}/vapi/workers?worker_id='
http DELETE '{{baseUrl}}/vapi/workers?worker_id='
wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/vapi/workers?worker_id='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/workers?worker_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "No workers matched the criteria."
}
GET Get Info
{{baseUrl}}/vapi/workers/info
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/workers/info");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/vapi/workers/info")
require "http/client"

url = "{{baseUrl}}/vapi/workers/info"

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}}/vapi/workers/info"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/vapi/workers/info");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/workers/info"

	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/vapi/workers/info HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vapi/workers/info")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/workers/info"))
    .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}}/vapi/workers/info")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/vapi/workers/info")
  .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}}/vapi/workers/info');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/vapi/workers/info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/workers/info';
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}}/vapi/workers/info',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/vapi/workers/info")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/vapi/workers/info',
  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}}/vapi/workers/info'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/vapi/workers/info');

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}}/vapi/workers/info'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/workers/info';
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}}/vapi/workers/info"]
                                                       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}}/vapi/workers/info" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/workers/info",
  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}}/vapi/workers/info');

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/workers/info');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/vapi/workers/info');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/vapi/workers/info' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/workers/info' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/vapi/workers/info")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/workers/info"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/workers/info"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/vapi/workers/info")

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/vapi/workers/info') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/workers/info";

    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}}/vapi/workers/info
http GET {{baseUrl}}/vapi/workers/info
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/vapi/workers/info
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/workers/info")! 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 Set Worker Settings
{{baseUrl}}/vapi/workers/settings
BODY json
{
  "worker_id": "",
  "tasks_to_give": "",
  "smart_memory": "",
  "cache_type": "",
  "cache_size": "",
  "vae_cpu": "",
  "reserve_vram": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vapi/workers/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  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/vapi/workers/settings" {:content-type :json
                                                                  :form-params {:worker_id ""
                                                                                :tasks_to_give ""
                                                                                :smart_memory ""
                                                                                :cache_type ""
                                                                                :cache_size ""
                                                                                :vae_cpu ""
                                                                                :reserve_vram ""}})
require "http/client"

url = "{{baseUrl}}/vapi/workers/settings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\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}}/vapi/workers/settings"),
    Content = new StringContent("{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\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}}/vapi/workers/settings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/vapi/workers/settings"

	payload := strings.NewReader("{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\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/vapi/workers/settings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 145

{
  "worker_id": "",
  "tasks_to_give": "",
  "smart_memory": "",
  "cache_type": "",
  "cache_size": "",
  "vae_cpu": "",
  "reserve_vram": ""
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vapi/workers/settings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vapi/workers/settings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\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  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vapi/workers/settings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/vapi/workers/settings")
  .header("content-type", "application/json")
  .body("{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\n}")
  .asString();
const data = JSON.stringify({
  worker_id: '',
  tasks_to_give: '',
  smart_memory: '',
  cache_type: '',
  cache_size: '',
  vae_cpu: '',
  reserve_vram: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/vapi/workers/settings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/workers/settings',
  headers: {'content-type': 'application/json'},
  data: {
    worker_id: '',
    tasks_to_give: '',
    smart_memory: '',
    cache_type: '',
    cache_size: '',
    vae_cpu: '',
    reserve_vram: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/vapi/workers/settings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"worker_id":"","tasks_to_give":"","smart_memory":"","cache_type":"","cache_size":"","vae_cpu":"","reserve_vram":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vapi/workers/settings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "worker_id": "",\n  "tasks_to_give": "",\n  "smart_memory": "",\n  "cache_type": "",\n  "cache_size": "",\n  "vae_cpu": "",\n  "reserve_vram": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vapi/workers/settings")
  .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/vapi/workers/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({
  worker_id: '',
  tasks_to_give: '',
  smart_memory: '',
  cache_type: '',
  cache_size: '',
  vae_cpu: '',
  reserve_vram: ''
}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vapi/workers/settings',
  headers: {'content-type': 'application/json'},
  body: {
    worker_id: '',
    tasks_to_give: '',
    smart_memory: '',
    cache_type: '',
    cache_size: '',
    vae_cpu: '',
    reserve_vram: ''
  },
  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}}/vapi/workers/settings');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  worker_id: '',
  tasks_to_give: '',
  smart_memory: '',
  cache_type: '',
  cache_size: '',
  vae_cpu: '',
  reserve_vram: ''
});

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}}/vapi/workers/settings',
  headers: {'content-type': 'application/json'},
  data: {
    worker_id: '',
    tasks_to_give: '',
    smart_memory: '',
    cache_type: '',
    cache_size: '',
    vae_cpu: '',
    reserve_vram: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/vapi/workers/settings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"worker_id":"","tasks_to_give":"","smart_memory":"","cache_type":"","cache_size":"","vae_cpu":"","reserve_vram":""}'
};

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 = @{ @"worker_id": @"",
                              @"tasks_to_give": @"",
                              @"smart_memory": @"",
                              @"cache_type": @"",
                              @"cache_size": @"",
                              @"vae_cpu": @"",
                              @"reserve_vram": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vapi/workers/settings"]
                                                       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}}/vapi/workers/settings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/vapi/workers/settings",
  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([
    'worker_id' => '',
    'tasks_to_give' => '',
    'smart_memory' => '',
    'cache_type' => '',
    'cache_size' => '',
    'vae_cpu' => '',
    'reserve_vram' => ''
  ]),
  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}}/vapi/workers/settings', [
  'body' => '{
  "worker_id": "",
  "tasks_to_give": "",
  "smart_memory": "",
  "cache_type": "",
  "cache_size": "",
  "vae_cpu": "",
  "reserve_vram": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/vapi/workers/settings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'worker_id' => '',
  'tasks_to_give' => '',
  'smart_memory' => '',
  'cache_type' => '',
  'cache_size' => '',
  'vae_cpu' => '',
  'reserve_vram' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'worker_id' => '',
  'tasks_to_give' => '',
  'smart_memory' => '',
  'cache_type' => '',
  'cache_size' => '',
  'vae_cpu' => '',
  'reserve_vram' => ''
]));
$request->setRequestUrl('{{baseUrl}}/vapi/workers/settings');
$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}}/vapi/workers/settings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "worker_id": "",
  "tasks_to_give": "",
  "smart_memory": "",
  "cache_type": "",
  "cache_size": "",
  "vae_cpu": "",
  "reserve_vram": ""
}'
$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vapi/workers/settings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "worker_id": "",
  "tasks_to_give": "",
  "smart_memory": "",
  "cache_type": "",
  "cache_size": "",
  "vae_cpu": "",
  "reserve_vram": ""
}'
import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/vapi/workers/settings", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/vapi/workers/settings"

payload = {
    "worker_id": "",
    "tasks_to_give": "",
    "smart_memory": "",
    "cache_type": "",
    "cache_size": "",
    "vae_cpu": "",
    "reserve_vram": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/vapi/workers/settings"

payload <- "{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\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}}/vapi/workers/settings")

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  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\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/vapi/workers/settings') do |req|
  req.body = "{\n  \"worker_id\": \"\",\n  \"tasks_to_give\": \"\",\n  \"smart_memory\": \"\",\n  \"cache_type\": \"\",\n  \"cache_size\": \"\",\n  \"vae_cpu\": \"\",\n  \"reserve_vram\": \"\"\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/vapi/workers/settings";

    let payload = json!({
        "worker_id": "",
        "tasks_to_give": "",
        "smart_memory": "",
        "cache_type": "",
        "cache_size": "",
        "vae_cpu": "",
        "reserve_vram": ""
    });

    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}}/vapi/workers/settings \
  --header 'content-type: application/json' \
  --data '{
  "worker_id": "",
  "tasks_to_give": "",
  "smart_memory": "",
  "cache_type": "",
  "cache_size": "",
  "vae_cpu": "",
  "reserve_vram": ""
}'
echo '{
  "worker_id": "",
  "tasks_to_give": "",
  "smart_memory": "",
  "cache_type": "",
  "cache_size": "",
  "vae_cpu": "",
  "reserve_vram": ""
}' |  \
  http POST {{baseUrl}}/vapi/workers/settings \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "worker_id": "",\n  "tasks_to_give": "",\n  "smart_memory": "",\n  "cache_type": "",\n  "cache_size": "",\n  "vae_cpu": "",\n  "reserve_vram": ""\n}' \
  --output-document \
  - {{baseUrl}}/vapi/workers/settings
import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "worker_id": "",
  "tasks_to_give": "",
  "smart_memory": "",
  "cache_type": "",
  "cache_size": "",
  "vae_cpu": "",
  "reserve_vram": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vapi/workers/settings")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "detail": "Can't find `worker_id` worker."
}
GET Custom Index
{{baseUrl}}/comfy/
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/comfy/");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/comfy/")
require "http/client"

url = "{{baseUrl}}/comfy/"

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}}/comfy/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/comfy/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/comfy/"

	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/comfy/ HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/comfy/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/comfy/"))
    .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}}/comfy/")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/comfy/")
  .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}}/comfy/');

xhr.send(data);
import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/comfy/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/comfy/';
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}}/comfy/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/comfy/")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/comfy/',
  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}}/comfy/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/comfy/');

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}}/comfy/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/comfy/';
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}}/comfy/"]
                                                       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}}/comfy/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/comfy/",
  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}}/comfy/');

echo $response->getBody();
setUrl('{{baseUrl}}/comfy/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/comfy/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/comfy/' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/comfy/' -Method GET 
import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/comfy/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))
import requests

url = "{{baseUrl}}/comfy/"

response = requests.get(url)

print(response.json())
library(httr)

url <- "{{baseUrl}}/comfy/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/comfy/")

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/comfy/') do |req|
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/comfy/";

    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}}/comfy/
http GET {{baseUrl}}/comfy/
wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/comfy/
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/comfy/")! 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()