Amazon Honeycode

POST BatchCreateTableRows

{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate

QUERY PARAMS

workbookId

tableId

BODY json

{
  "rowsToCreate": [
    {
      "batchItemId": "",
      "cellsToCreate": ""
    }
  ],
  "clientRequestToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate");

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  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate" {:content-type :json
                                                                                                   :form-params {:rowsToCreate [{:batchItemId ""
                                                                                                                                 :cellsToCreate ""}]
                                                                                                                 :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate"),
    Content = new StringContent("{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate"

	payload := strings.NewReader("{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/batchcreate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 118

{
  "rowsToCreate": [
    {
      "batchItemId": "",
      "cellsToCreate": ""
    }
  ],
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate")
  .header("content-type", "application/json")
  .body("{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  rowsToCreate: [
    {
      batchItemId: '',
      cellsToCreate: ''
    }
  ],
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate',
  headers: {'content-type': 'application/json'},
  data: {rowsToCreate: [{batchItemId: '', cellsToCreate: ''}], clientRequestToken: ''}
};

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rowsToCreate":[{"batchItemId":"","cellsToCreate":""}],"clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "rowsToCreate": [\n    {\n      "batchItemId": "",\n      "cellsToCreate": ""\n    }\n  ],\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate")
  .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/workbooks/:workbookId/tables/:tableId/rows/batchcreate',
  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({rowsToCreate: [{batchItemId: '', cellsToCreate: ''}], clientRequestToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate',
  headers: {'content-type': 'application/json'},
  body: {rowsToCreate: [{batchItemId: '', cellsToCreate: ''}], clientRequestToken: ''},
  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}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate');

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

req.type('json');
req.send({
  rowsToCreate: [
    {
      batchItemId: '',
      cellsToCreate: ''
    }
  ],
  clientRequestToken: ''
});

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}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate',
  headers: {'content-type': 'application/json'},
  data: {rowsToCreate: [{batchItemId: '', cellsToCreate: ''}], clientRequestToken: ''}
};

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

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rowsToCreate":[{"batchItemId":"","cellsToCreate":""}],"clientRequestToken":""}'
};

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 = @{ @"rowsToCreate": @[ @{ @"batchItemId": @"", @"cellsToCreate": @"" } ],
                              @"clientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate"]
                                                       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}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate",
  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([
    'rowsToCreate' => [
        [
                'batchItemId' => '',
                'cellsToCreate' => ''
        ]
    ],
    'clientRequestToken' => ''
  ]),
  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}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate', [
  'body' => '{
  "rowsToCreate": [
    {
      "batchItemId": "",
      "cellsToCreate": ""
    }
  ],
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'rowsToCreate' => [
    [
        'batchItemId' => '',
        'cellsToCreate' => ''
    ]
  ],
  'clientRequestToken' => ''
]));

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

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

append(json_encode([
  'rowsToCreate' => [
    [
        'batchItemId' => '',
        'cellsToCreate' => ''
    ]
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate');
$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}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rowsToCreate": [
    {
      "batchItemId": "",
      "cellsToCreate": ""
    }
  ],
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rowsToCreate": [
    {
      "batchItemId": "",
      "cellsToCreate": ""
    }
  ],
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/workbooks/:workbookId/tables/:tableId/rows/batchcreate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate"

payload = {
    "rowsToCreate": [
        {
            "batchItemId": "",
            "cellsToCreate": ""
        }
    ],
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate"

payload <- "{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate")

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  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/batchcreate') do |req|
  req.body = "{\n  \"rowsToCreate\": [\n    {\n      \"batchItemId\": \"\",\n      \"cellsToCreate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate";

    let payload = json!({
        "rowsToCreate": (
            json!({
                "batchItemId": "",
                "cellsToCreate": ""
            })
        ),
        "clientRequestToken": ""
    });

    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}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate \
  --header 'content-type: application/json' \
  --data '{
  "rowsToCreate": [
    {
      "batchItemId": "",
      "cellsToCreate": ""
    }
  ],
  "clientRequestToken": ""
}'

echo '{
  "rowsToCreate": [
    {
      "batchItemId": "",
      "cellsToCreate": ""
    }
  ],
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "rowsToCreate": [\n    {\n      "batchItemId": "",\n      "cellsToCreate": ""\n    }\n  ],\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchcreate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "rowsToCreate": [
    [
      "batchItemId": "",
      "cellsToCreate": ""
    ]
  ],
  "clientRequestToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST BatchDeleteTableRows

{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete

QUERY PARAMS

workbookId

tableId

BODY json

{
  "rowIds": [],
  "clientRequestToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete");

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  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete" {:content-type :json
                                                                                                   :form-params {:rowIds []
                                                                                                                 :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete"),
    Content = new StringContent("{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete"

	payload := strings.NewReader("{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/batchdelete HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "rowIds": [],
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\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  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete")
  .header("content-type", "application/json")
  .body("{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  rowIds: [],
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete',
  headers: {'content-type': 'application/json'},
  data: {rowIds: [], clientRequestToken: ''}
};

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rowIds":[],"clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "rowIds": [],\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete")
  .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/workbooks/:workbookId/tables/:tableId/rows/batchdelete',
  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({rowIds: [], clientRequestToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete',
  headers: {'content-type': 'application/json'},
  body: {rowIds: [], clientRequestToken: ''},
  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}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete');

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

req.type('json');
req.send({
  rowIds: [],
  clientRequestToken: ''
});

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}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete',
  headers: {'content-type': 'application/json'},
  data: {rowIds: [], clientRequestToken: ''}
};

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

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rowIds":[],"clientRequestToken":""}'
};

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 = @{ @"rowIds": @[  ],
                              @"clientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete"]
                                                       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}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete",
  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([
    'rowIds' => [
        
    ],
    'clientRequestToken' => ''
  ]),
  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}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete', [
  'body' => '{
  "rowIds": [],
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'rowIds' => [
    
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete');
$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}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rowIds": [],
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rowIds": [],
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/workbooks/:workbookId/tables/:tableId/rows/batchdelete", payload, headers)

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

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

import requests

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete"

payload = {
    "rowIds": [],
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete"

payload <- "{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete")

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  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/batchdelete') do |req|
  req.body = "{\n  \"rowIds\": [],\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete";

    let payload = json!({
        "rowIds": (),
        "clientRequestToken": ""
    });

    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}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete \
  --header 'content-type: application/json' \
  --data '{
  "rowIds": [],
  "clientRequestToken": ""
}'

echo '{
  "rowIds": [],
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "rowIds": [],\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchdelete

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "rowIds": [],
  "clientRequestToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST BatchUpdateTableRows

{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate

QUERY PARAMS

workbookId

tableId

BODY json

{
  "rowsToUpdate": [
    {
      "rowId": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate");

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  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate" {:content-type :json
                                                                                                   :form-params {:rowsToUpdate [{:rowId ""
                                                                                                                                 :cellsToUpdate ""}]
                                                                                                                 :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate"),
    Content = new StringContent("{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate"

	payload := strings.NewReader("{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/batchupdate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "rowsToUpdate": [
    {
      "rowId": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate")
  .header("content-type", "application/json")
  .body("{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  rowsToUpdate: [
    {
      rowId: '',
      cellsToUpdate: ''
    }
  ],
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate',
  headers: {'content-type': 'application/json'},
  data: {rowsToUpdate: [{rowId: '', cellsToUpdate: ''}], clientRequestToken: ''}
};

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rowsToUpdate":[{"rowId":"","cellsToUpdate":""}],"clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "rowsToUpdate": [\n    {\n      "rowId": "",\n      "cellsToUpdate": ""\n    }\n  ],\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate")
  .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/workbooks/:workbookId/tables/:tableId/rows/batchupdate',
  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({rowsToUpdate: [{rowId: '', cellsToUpdate: ''}], clientRequestToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate',
  headers: {'content-type': 'application/json'},
  body: {rowsToUpdate: [{rowId: '', cellsToUpdate: ''}], clientRequestToken: ''},
  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}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate');

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

req.type('json');
req.send({
  rowsToUpdate: [
    {
      rowId: '',
      cellsToUpdate: ''
    }
  ],
  clientRequestToken: ''
});

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}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate',
  headers: {'content-type': 'application/json'},
  data: {rowsToUpdate: [{rowId: '', cellsToUpdate: ''}], clientRequestToken: ''}
};

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

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rowsToUpdate":[{"rowId":"","cellsToUpdate":""}],"clientRequestToken":""}'
};

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 = @{ @"rowsToUpdate": @[ @{ @"rowId": @"", @"cellsToUpdate": @"" } ],
                              @"clientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate"]
                                                       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}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate",
  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([
    'rowsToUpdate' => [
        [
                'rowId' => '',
                'cellsToUpdate' => ''
        ]
    ],
    'clientRequestToken' => ''
  ]),
  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}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate', [
  'body' => '{
  "rowsToUpdate": [
    {
      "rowId": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'rowsToUpdate' => [
    [
        'rowId' => '',
        'cellsToUpdate' => ''
    ]
  ],
  'clientRequestToken' => ''
]));

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

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

append(json_encode([
  'rowsToUpdate' => [
    [
        'rowId' => '',
        'cellsToUpdate' => ''
    ]
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate');
$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}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rowsToUpdate": [
    {
      "rowId": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rowsToUpdate": [
    {
      "rowId": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/workbooks/:workbookId/tables/:tableId/rows/batchupdate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate"

payload = {
    "rowsToUpdate": [
        {
            "rowId": "",
            "cellsToUpdate": ""
        }
    ],
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate"

payload <- "{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate")

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  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/batchupdate') do |req|
  req.body = "{\n  \"rowsToUpdate\": [\n    {\n      \"rowId\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate";

    let payload = json!({
        "rowsToUpdate": (
            json!({
                "rowId": "",
                "cellsToUpdate": ""
            })
        ),
        "clientRequestToken": ""
    });

    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}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate \
  --header 'content-type: application/json' \
  --data '{
  "rowsToUpdate": [
    {
      "rowId": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}'

echo '{
  "rowsToUpdate": [
    {
      "rowId": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "rowsToUpdate": [\n    {\n      "rowId": "",\n      "cellsToUpdate": ""\n    }\n  ],\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupdate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "rowsToUpdate": [
    [
      "rowId": "",
      "cellsToUpdate": ""
    ]
  ],
  "clientRequestToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST BatchUpsertTableRows

{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert

QUERY PARAMS

workbookId

tableId

BODY json

{
  "rowsToUpsert": [
    {
      "batchItemId": "",
      "filter": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert");

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  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert" {:content-type :json
                                                                                                   :form-params {:rowsToUpsert [{:batchItemId ""
                                                                                                                                 :filter ""
                                                                                                                                 :cellsToUpdate ""}]
                                                                                                                 :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert"),
    Content = new StringContent("{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert"

	payload := strings.NewReader("{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/batchupsert HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 138

{
  "rowsToUpsert": [
    {
      "batchItemId": "",
      "filter": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert")
  .header("content-type", "application/json")
  .body("{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  rowsToUpsert: [
    {
      batchItemId: '',
      filter: '',
      cellsToUpdate: ''
    }
  ],
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert',
  headers: {'content-type': 'application/json'},
  data: {
    rowsToUpsert: [{batchItemId: '', filter: '', cellsToUpdate: ''}],
    clientRequestToken: ''
  }
};

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rowsToUpsert":[{"batchItemId":"","filter":"","cellsToUpdate":""}],"clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "rowsToUpsert": [\n    {\n      "batchItemId": "",\n      "filter": "",\n      "cellsToUpdate": ""\n    }\n  ],\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert")
  .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/workbooks/:workbookId/tables/:tableId/rows/batchupsert',
  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({
  rowsToUpsert: [{batchItemId: '', filter: '', cellsToUpdate: ''}],
  clientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert',
  headers: {'content-type': 'application/json'},
  body: {
    rowsToUpsert: [{batchItemId: '', filter: '', cellsToUpdate: ''}],
    clientRequestToken: ''
  },
  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}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert');

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

req.type('json');
req.send({
  rowsToUpsert: [
    {
      batchItemId: '',
      filter: '',
      cellsToUpdate: ''
    }
  ],
  clientRequestToken: ''
});

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}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert',
  headers: {'content-type': 'application/json'},
  data: {
    rowsToUpsert: [{batchItemId: '', filter: '', cellsToUpdate: ''}],
    clientRequestToken: ''
  }
};

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

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rowsToUpsert":[{"batchItemId":"","filter":"","cellsToUpdate":""}],"clientRequestToken":""}'
};

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 = @{ @"rowsToUpsert": @[ @{ @"batchItemId": @"", @"filter": @"", @"cellsToUpdate": @"" } ],
                              @"clientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert"]
                                                       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}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert",
  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([
    'rowsToUpsert' => [
        [
                'batchItemId' => '',
                'filter' => '',
                'cellsToUpdate' => ''
        ]
    ],
    'clientRequestToken' => ''
  ]),
  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}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert', [
  'body' => '{
  "rowsToUpsert": [
    {
      "batchItemId": "",
      "filter": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'rowsToUpsert' => [
    [
        'batchItemId' => '',
        'filter' => '',
        'cellsToUpdate' => ''
    ]
  ],
  'clientRequestToken' => ''
]));

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

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

append(json_encode([
  'rowsToUpsert' => [
    [
        'batchItemId' => '',
        'filter' => '',
        'cellsToUpdate' => ''
    ]
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert');
$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}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rowsToUpsert": [
    {
      "batchItemId": "",
      "filter": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rowsToUpsert": [
    {
      "batchItemId": "",
      "filter": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/workbooks/:workbookId/tables/:tableId/rows/batchupsert", payload, headers)

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

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

import requests

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert"

payload = {
    "rowsToUpsert": [
        {
            "batchItemId": "",
            "filter": "",
            "cellsToUpdate": ""
        }
    ],
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert"

payload <- "{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert")

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  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/batchupsert') do |req|
  req.body = "{\n  \"rowsToUpsert\": [\n    {\n      \"batchItemId\": \"\",\n      \"filter\": \"\",\n      \"cellsToUpdate\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert";

    let payload = json!({
        "rowsToUpsert": (
            json!({
                "batchItemId": "",
                "filter": "",
                "cellsToUpdate": ""
            })
        ),
        "clientRequestToken": ""
    });

    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}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert \
  --header 'content-type: application/json' \
  --data '{
  "rowsToUpsert": [
    {
      "batchItemId": "",
      "filter": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}'

echo '{
  "rowsToUpsert": [
    {
      "batchItemId": "",
      "filter": "",
      "cellsToUpdate": ""
    }
  ],
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "rowsToUpsert": [\n    {\n      "batchItemId": "",\n      "filter": "",\n      "cellsToUpdate": ""\n    }\n  ],\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "rowsToUpsert": [
    [
      "batchItemId": "",
      "filter": "",
      "cellsToUpdate": ""
    ]
  ],
  "clientRequestToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/batchupsert")! 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 DescribeTableDataImportJob

{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId

QUERY PARAMS

workbookId

tableId

jobId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId")

require "http/client"

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId"

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

var client = new RestClient("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId"

	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/workbooks/:workbookId/tables/:tableId/import/:jobId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId"))
    .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}}/workbooks/:workbookId/tables/:tableId/import/:jobId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId")
  .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}}/workbooks/:workbookId/tables/:tableId/import/:jobId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId'
};

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId';
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}}/workbooks/:workbookId/tables/:tableId/import/:jobId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/workbooks/:workbookId/tables/:tableId/import/:jobId',
  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}}/workbooks/:workbookId/tables/:tableId/import/:jobId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId');

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}}/workbooks/:workbookId/tables/:tableId/import/:jobId'
};

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

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId';
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}}/workbooks/:workbookId/tables/:tableId/import/:jobId"]
                                                       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}}/workbooks/:workbookId/tables/:tableId/import/:jobId" in

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

 "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId",
  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}}/workbooks/:workbookId/tables/:tableId/import/:jobId');

echo $response->getBody();

setUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/workbooks/:workbookId/tables/:tableId/import/:jobId")

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

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

import requests

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId")

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/workbooks/:workbookId/tables/:tableId/import/:jobId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId";

    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}}/workbooks/:workbookId/tables/:tableId/import/:jobId

http GET {{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import/:jobId")! 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 GetScreenData

{{baseUrl}}/screendata

BODY json

{
  "workbookId": "",
  "appId": "",
  "screenId": "",
  "variables": {},
  "maxResults": 0,
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"workbookId\": \"\",\n  \"appId\": \"\",\n  \"screenId\": \"\",\n  \"variables\": {},\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/screendata" {:content-type :json
                                                       :form-params {:workbookId ""
                                                                     :appId ""
                                                                     :screenId ""
                                                                     :variables {}
                                                                     :maxResults 0
                                                                     :nextToken ""}})

require "http/client"

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

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"workbookId\": \"\",\n  \"appId\": \"\",\n  \"screenId\": \"\",\n  \"variables\": {},\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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/screendata HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "workbookId": "",
  "appId": "",
  "screenId": "",
  "variables": {},
  "maxResults": 0,
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/screendata")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"workbookId\": \"\",\n  \"appId\": \"\",\n  \"screenId\": \"\",\n  \"variables\": {},\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/screendata")
  .header("content-type", "application/json")
  .body("{\n  \"workbookId\": \"\",\n  \"appId\": \"\",\n  \"screenId\": \"\",\n  \"variables\": {},\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  workbookId: '',
  appId: '',
  screenId: '',
  variables: {},
  maxResults: 0,
  nextToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/screendata',
  headers: {'content-type': 'application/json'},
  data: {
    workbookId: '',
    appId: '',
    screenId: '',
    variables: {},
    maxResults: 0,
    nextToken: ''
  }
};

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

const url = '{{baseUrl}}/screendata';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"workbookId":"","appId":"","screenId":"","variables":{},"maxResults":0,"nextToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/screendata',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "workbookId": "",\n  "appId": "",\n  "screenId": "",\n  "variables": {},\n  "maxResults": 0,\n  "nextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"workbookId\": \"\",\n  \"appId\": \"\",\n  \"screenId\": \"\",\n  \"variables\": {},\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/screendata")
  .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/screendata',
  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({
  workbookId: '',
  appId: '',
  screenId: '',
  variables: {},
  maxResults: 0,
  nextToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/screendata',
  headers: {'content-type': 'application/json'},
  body: {
    workbookId: '',
    appId: '',
    screenId: '',
    variables: {},
    maxResults: 0,
    nextToken: ''
  },
  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}}/screendata');

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

req.type('json');
req.send({
  workbookId: '',
  appId: '',
  screenId: '',
  variables: {},
  maxResults: 0,
  nextToken: ''
});

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}}/screendata',
  headers: {'content-type': 'application/json'},
  data: {
    workbookId: '',
    appId: '',
    screenId: '',
    variables: {},
    maxResults: 0,
    nextToken: ''
  }
};

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

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

const url = '{{baseUrl}}/screendata';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"workbookId":"","appId":"","screenId":"","variables":{},"maxResults":0,"nextToken":""}'
};

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 = @{ @"workbookId": @"",
                              @"appId": @"",
                              @"screenId": @"",
                              @"variables": @{  },
                              @"maxResults": @0,
                              @"nextToken": @"" };

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

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

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

 "{{baseUrl}}/screendata",
  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([
    'workbookId' => '',
    'appId' => '',
    'screenId' => '',
    'variables' => [
        
    ],
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  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}}/screendata', [
  'body' => '{
  "workbookId": "",
  "appId": "",
  "screenId": "",
  "variables": {},
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'workbookId' => '',
  'appId' => '',
  'screenId' => '',
  'variables' => [
    
  ],
  'maxResults' => 0,
  'nextToken' => ''
]));

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

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

append(json_encode([
  'workbookId' => '',
  'appId' => '',
  'screenId' => '',
  'variables' => [
    
  ],
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/screendata');
$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}}/screendata' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "workbookId": "",
  "appId": "",
  "screenId": "",
  "variables": {},
  "maxResults": 0,
  "nextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/screendata' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "workbookId": "",
  "appId": "",
  "screenId": "",
  "variables": {},
  "maxResults": 0,
  "nextToken": ""
}'

import http.client

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

payload = "{\n  \"workbookId\": \"\",\n  \"appId\": \"\",\n  \"screenId\": \"\",\n  \"variables\": {},\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/screendata"

payload = {
    "workbookId": "",
    "appId": "",
    "screenId": "",
    "variables": {},
    "maxResults": 0,
    "nextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"workbookId\": \"\",\n  \"appId\": \"\",\n  \"screenId\": \"\",\n  \"variables\": {},\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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}}/screendata")

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  \"workbookId\": \"\",\n  \"appId\": \"\",\n  \"screenId\": \"\",\n  \"variables\": {},\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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/screendata') do |req|
  req.body = "{\n  \"workbookId\": \"\",\n  \"appId\": \"\",\n  \"screenId\": \"\",\n  \"variables\": {},\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "workbookId": "",
        "appId": "",
        "screenId": "",
        "variables": json!({}),
        "maxResults": 0,
        "nextToken": ""
    });

    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}}/screendata \
  --header 'content-type: application/json' \
  --data '{
  "workbookId": "",
  "appId": "",
  "screenId": "",
  "variables": {},
  "maxResults": 0,
  "nextToken": ""
}'

echo '{
  "workbookId": "",
  "appId": "",
  "screenId": "",
  "variables": {},
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/screendata \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "workbookId": "",\n  "appId": "",\n  "screenId": "",\n  "variables": {},\n  "maxResults": 0,\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/screendata

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "workbookId": "",
  "appId": "",
  "screenId": "",
  "variables": [],
  "maxResults": 0,
  "nextToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST InvokeScreenAutomation

{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId

QUERY PARAMS

workbookId

appId

screenId

automationId

BODY json

{
  "variables": {},
  "rowId": "",
  "clientRequestToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId");

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  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId" {:content-type :json
                                                                                                                          :form-params {:variables {}
                                                                                                                                        :rowId ""
                                                                                                                                        :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId"),
    Content = new StringContent("{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId"

	payload := strings.NewReader("{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 64

{
  "variables": {},
  "rowId": "",
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\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  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId")
  .header("content-type", "application/json")
  .body("{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  variables: {},
  rowId: '',
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId',
  headers: {'content-type': 'application/json'},
  data: {variables: {}, rowId: '', clientRequestToken: ''}
};

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

const url = '{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"variables":{},"rowId":"","clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "variables": {},\n  "rowId": "",\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId")
  .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/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId',
  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({variables: {}, rowId: '', clientRequestToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId',
  headers: {'content-type': 'application/json'},
  body: {variables: {}, rowId: '', clientRequestToken: ''},
  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}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId');

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

req.type('json');
req.send({
  variables: {},
  rowId: '',
  clientRequestToken: ''
});

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}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId',
  headers: {'content-type': 'application/json'},
  data: {variables: {}, rowId: '', clientRequestToken: ''}
};

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

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

const url = '{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"variables":{},"rowId":"","clientRequestToken":""}'
};

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 = @{ @"variables": @{  },
                              @"rowId": @"",
                              @"clientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId"]
                                                       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}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId",
  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([
    'variables' => [
        
    ],
    'rowId' => '',
    'clientRequestToken' => ''
  ]),
  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}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId', [
  'body' => '{
  "variables": {},
  "rowId": "",
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'variables' => [
    
  ],
  'rowId' => '',
  'clientRequestToken' => ''
]));

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

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

append(json_encode([
  'variables' => [
    
  ],
  'rowId' => '',
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId');
$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}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "variables": {},
  "rowId": "",
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "variables": {},
  "rowId": "",
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId"

payload = {
    "variables": {},
    "rowId": "",
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId"

payload <- "{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId")

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  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId') do |req|
  req.body = "{\n  \"variables\": {},\n  \"rowId\": \"\",\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId";

    let payload = json!({
        "variables": json!({}),
        "rowId": "",
        "clientRequestToken": ""
    });

    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}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId \
  --header 'content-type: application/json' \
  --data '{
  "variables": {},
  "rowId": "",
  "clientRequestToken": ""
}'

echo '{
  "variables": {},
  "rowId": "",
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "variables": {},\n  "rowId": "",\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "variables": [],
  "rowId": "",
  "clientRequestToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/workbooks/:workbookId/apps/:appId/screens/:screenId/automations/:automationId")! 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 ListTableColumns

{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns

QUERY PARAMS

workbookId

tableId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns")

require "http/client"

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns"

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

var client = new RestClient("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns"

	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/workbooks/:workbookId/tables/:tableId/columns HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns"))
    .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}}/workbooks/:workbookId/tables/:tableId/columns")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns")
  .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}}/workbooks/:workbookId/tables/:tableId/columns');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns'
};

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns';
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}}/workbooks/:workbookId/tables/:tableId/columns',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns');

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}}/workbooks/:workbookId/tables/:tableId/columns'
};

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

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns';
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}}/workbooks/:workbookId/tables/:tableId/columns"]
                                                       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}}/workbooks/:workbookId/tables/:tableId/columns" in

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

 "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns",
  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}}/workbooks/:workbookId/tables/:tableId/columns');

echo $response->getBody();

setUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/workbooks/:workbookId/tables/:tableId/columns")

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

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

import requests

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns")

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/workbooks/:workbookId/tables/:tableId/columns') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns";

    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}}/workbooks/:workbookId/tables/:tableId/columns

http GET {{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/columns")! 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 ListTableRows

{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list

QUERY PARAMS

workbookId

tableId

BODY json

{
  "rowIds": [],
  "maxResults": 0,
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list");

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  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list" {:content-type :json
                                                                                            :form-params {:rowIds []
                                                                                                          :maxResults 0
                                                                                                          :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/list"),
    Content = new StringContent("{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/list");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list"

	payload := strings.NewReader("{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/list HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 56

{
  "rowIds": [],
  "maxResults": 0,
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list")
  .header("content-type", "application/json")
  .body("{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  rowIds: [],
  maxResults: 0,
  nextToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list',
  headers: {'content-type': 'application/json'},
  data: {rowIds: [], maxResults: 0, nextToken: ''}
};

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rowIds":[],"maxResults":0,"nextToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "rowIds": [],\n  "maxResults": 0,\n  "nextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list")
  .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/workbooks/:workbookId/tables/:tableId/rows/list',
  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({rowIds: [], maxResults: 0, nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list',
  headers: {'content-type': 'application/json'},
  body: {rowIds: [], maxResults: 0, nextToken: ''},
  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}}/workbooks/:workbookId/tables/:tableId/rows/list');

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

req.type('json');
req.send({
  rowIds: [],
  maxResults: 0,
  nextToken: ''
});

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}}/workbooks/:workbookId/tables/:tableId/rows/list',
  headers: {'content-type': 'application/json'},
  data: {rowIds: [], maxResults: 0, nextToken: ''}
};

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

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rowIds":[],"maxResults":0,"nextToken":""}'
};

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 = @{ @"rowIds": @[  ],
                              @"maxResults": @0,
                              @"nextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list"]
                                                       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}}/workbooks/:workbookId/tables/:tableId/rows/list" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}" in

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

 "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list",
  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([
    'rowIds' => [
        
    ],
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  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}}/workbooks/:workbookId/tables/:tableId/rows/list', [
  'body' => '{
  "rowIds": [],
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'rowIds' => [
    
  ],
  'maxResults' => 0,
  'nextToken' => ''
]));

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

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

append(json_encode([
  'rowIds' => [
    
  ],
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list');
$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}}/workbooks/:workbookId/tables/:tableId/rows/list' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rowIds": [],
  "maxResults": 0,
  "nextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rowIds": [],
  "maxResults": 0,
  "nextToken": ""
}'

import http.client

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

payload = "{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/workbooks/:workbookId/tables/:tableId/rows/list", payload, headers)

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

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

import requests

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list"

payload = {
    "rowIds": [],
    "maxResults": 0,
    "nextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list"

payload <- "{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/list")

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  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/list') do |req|
  req.body = "{\n  \"rowIds\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list";

    let payload = json!({
        "rowIds": (),
        "maxResults": 0,
        "nextToken": ""
    });

    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}}/workbooks/:workbookId/tables/:tableId/rows/list \
  --header 'content-type: application/json' \
  --data '{
  "rowIds": [],
  "maxResults": 0,
  "nextToken": ""
}'

echo '{
  "rowIds": [],
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "rowIds": [],\n  "maxResults": 0,\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "rowIds": [],
  "maxResults": 0,
  "nextToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/list")! 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 ListTables

{{baseUrl}}/workbooks/:workbookId/tables

QUERY PARAMS

workbookId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/workbooks/:workbookId/tables");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/workbooks/:workbookId/tables")

require "http/client"

url = "{{baseUrl}}/workbooks/:workbookId/tables"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/workbooks/:workbookId/tables"

	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/workbooks/:workbookId/tables HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/workbooks/:workbookId/tables'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/workbooks/:workbookId/tables');

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}}/workbooks/:workbookId/tables'};

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

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

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

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

 "{{baseUrl}}/workbooks/:workbookId/tables",
  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}}/workbooks/:workbookId/tables');

echo $response->getBody();

setUrl('{{baseUrl}}/workbooks/:workbookId/tables');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/workbooks/:workbookId/tables' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/workbooks/:workbookId/tables' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/workbooks/:workbookId/tables")

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

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

import requests

url = "{{baseUrl}}/workbooks/:workbookId/tables"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/workbooks/:workbookId/tables"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/workbooks/:workbookId/tables")

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/workbooks/:workbookId/tables') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/workbooks/:workbookId/tables

http GET {{baseUrl}}/workbooks/:workbookId/tables

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/workbooks/:workbookId/tables

import Foundation

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

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

dataTask.resume()

GET ListTagsForResource

{{baseUrl}}/tags/:resourceArn

QUERY PARAMS

resourceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tags/:resourceArn")

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/tags/:resourceArn"

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

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

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

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

}

GET /baseUrl/tags/:resourceArn HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tags/:resourceArn")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/tags/:resourceArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

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

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tags/:resourceArn');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

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

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

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn" in

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

 "{{baseUrl}}/tags/:resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tags/:resourceArn');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/tags/:resourceArn")

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

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

import requests

url = "{{baseUrl}}/tags/:resourceArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/tags/:resourceArn') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/tags/:resourceArn

http GET {{baseUrl}}/tags/:resourceArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

import Foundation

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

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

dataTask.resume()

POST QueryTableRows

{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query

QUERY PARAMS

workbookId

tableId

BODY json

{
  "filterFormula": {
    "formula": "",
    "contextRowId": ""
  },
  "maxResults": 0,
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query");

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  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query" {:content-type :json
                                                                                             :form-params {:filterFormula {:formula ""
                                                                                                                           :contextRowId ""}
                                                                                                           :maxResults 0
                                                                                                           :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/query"),
    Content = new StringContent("{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/query");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query"

	payload := strings.NewReader("{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/query HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 108

{
  "filterFormula": {
    "formula": "",
    "contextRowId": ""
  },
  "maxResults": 0,
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query")
  .header("content-type", "application/json")
  .body("{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  filterFormula: {
    formula: '',
    contextRowId: ''
  },
  maxResults: 0,
  nextToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query',
  headers: {'content-type': 'application/json'},
  data: {filterFormula: {formula: '', contextRowId: ''}, maxResults: 0, nextToken: ''}
};

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"filterFormula":{"formula":"","contextRowId":""},"maxResults":0,"nextToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "filterFormula": {\n    "formula": "",\n    "contextRowId": ""\n  },\n  "maxResults": 0,\n  "nextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query")
  .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/workbooks/:workbookId/tables/:tableId/rows/query',
  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({filterFormula: {formula: '', contextRowId: ''}, maxResults: 0, nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query',
  headers: {'content-type': 'application/json'},
  body: {filterFormula: {formula: '', contextRowId: ''}, maxResults: 0, nextToken: ''},
  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}}/workbooks/:workbookId/tables/:tableId/rows/query');

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

req.type('json');
req.send({
  filterFormula: {
    formula: '',
    contextRowId: ''
  },
  maxResults: 0,
  nextToken: ''
});

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}}/workbooks/:workbookId/tables/:tableId/rows/query',
  headers: {'content-type': 'application/json'},
  data: {filterFormula: {formula: '', contextRowId: ''}, maxResults: 0, nextToken: ''}
};

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

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"filterFormula":{"formula":"","contextRowId":""},"maxResults":0,"nextToken":""}'
};

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 = @{ @"filterFormula": @{ @"formula": @"", @"contextRowId": @"" },
                              @"maxResults": @0,
                              @"nextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query"]
                                                       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}}/workbooks/:workbookId/tables/:tableId/rows/query" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}" in

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

 "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query",
  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([
    'filterFormula' => [
        'formula' => '',
        'contextRowId' => ''
    ],
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  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}}/workbooks/:workbookId/tables/:tableId/rows/query', [
  'body' => '{
  "filterFormula": {
    "formula": "",
    "contextRowId": ""
  },
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'filterFormula' => [
    'formula' => '',
    'contextRowId' => ''
  ],
  'maxResults' => 0,
  'nextToken' => ''
]));

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

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

append(json_encode([
  'filterFormula' => [
    'formula' => '',
    'contextRowId' => ''
  ],
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query');
$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}}/workbooks/:workbookId/tables/:tableId/rows/query' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "filterFormula": {
    "formula": "",
    "contextRowId": ""
  },
  "maxResults": 0,
  "nextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "filterFormula": {
    "formula": "",
    "contextRowId": ""
  },
  "maxResults": 0,
  "nextToken": ""
}'

import http.client

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

payload = "{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/workbooks/:workbookId/tables/:tableId/rows/query", payload, headers)

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

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

import requests

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query"

payload = {
    "filterFormula": {
        "formula": "",
        "contextRowId": ""
    },
    "maxResults": 0,
    "nextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query"

payload <- "{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/rows/query")

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  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/rows/query') do |req|
  req.body = "{\n  \"filterFormula\": {\n    \"formula\": \"\",\n    \"contextRowId\": \"\"\n  },\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query";

    let payload = json!({
        "filterFormula": json!({
            "formula": "",
            "contextRowId": ""
        }),
        "maxResults": 0,
        "nextToken": ""
    });

    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}}/workbooks/:workbookId/tables/:tableId/rows/query \
  --header 'content-type: application/json' \
  --data '{
  "filterFormula": {
    "formula": "",
    "contextRowId": ""
  },
  "maxResults": 0,
  "nextToken": ""
}'

echo '{
  "filterFormula": {
    "formula": "",
    "contextRowId": ""
  },
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "filterFormula": {\n    "formula": "",\n    "contextRowId": ""\n  },\n  "maxResults": 0,\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/workbooks/:workbookId/tables/:tableId/rows/query

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "filterFormula": [
    "formula": "",
    "contextRowId": ""
  ],
  "maxResults": 0,
  "nextToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST StartTableDataImportJob

{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import

QUERY PARAMS

workbookId

tableId

BODY json

{
  "dataSource": {
    "dataSourceConfig": ""
  },
  "dataFormat": "",
  "importOptions": {
    "destinationOptions": "",
    "delimitedTextOptions": ""
  },
  "clientRequestToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import" {:content-type :json
                                                                                         :form-params {:dataSource {:dataSourceConfig ""}
                                                                                                       :dataFormat ""
                                                                                                       :importOptions {:destinationOptions ""
                                                                                                                       :delimitedTextOptions ""}
                                                                                                       :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/import"),
    Content = new StringContent("{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/import");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import"

	payload := strings.NewReader("{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/import HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 187

{
  "dataSource": {
    "dataSourceConfig": ""
  },
  "dataFormat": "",
  "importOptions": {
    "destinationOptions": "",
    "delimitedTextOptions": ""
  },
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\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  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import")
  .header("content-type", "application/json")
  .body("{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  dataSource: {
    dataSourceConfig: ''
  },
  dataFormat: '',
  importOptions: {
    destinationOptions: '',
    delimitedTextOptions: ''
  },
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import',
  headers: {'content-type': 'application/json'},
  data: {
    dataSource: {dataSourceConfig: ''},
    dataFormat: '',
    importOptions: {destinationOptions: '', delimitedTextOptions: ''},
    clientRequestToken: ''
  }
};

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"dataSource":{"dataSourceConfig":""},"dataFormat":"","importOptions":{"destinationOptions":"","delimitedTextOptions":""},"clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "dataSource": {\n    "dataSourceConfig": ""\n  },\n  "dataFormat": "",\n  "importOptions": {\n    "destinationOptions": "",\n    "delimitedTextOptions": ""\n  },\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/workbooks/:workbookId/tables/:tableId/import',
  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({
  dataSource: {dataSourceConfig: ''},
  dataFormat: '',
  importOptions: {destinationOptions: '', delimitedTextOptions: ''},
  clientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import',
  headers: {'content-type': 'application/json'},
  body: {
    dataSource: {dataSourceConfig: ''},
    dataFormat: '',
    importOptions: {destinationOptions: '', delimitedTextOptions: ''},
    clientRequestToken: ''
  },
  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}}/workbooks/:workbookId/tables/:tableId/import');

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

req.type('json');
req.send({
  dataSource: {
    dataSourceConfig: ''
  },
  dataFormat: '',
  importOptions: {
    destinationOptions: '',
    delimitedTextOptions: ''
  },
  clientRequestToken: ''
});

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}}/workbooks/:workbookId/tables/:tableId/import',
  headers: {'content-type': 'application/json'},
  data: {
    dataSource: {dataSourceConfig: ''},
    dataFormat: '',
    importOptions: {destinationOptions: '', delimitedTextOptions: ''},
    clientRequestToken: ''
  }
};

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

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

const url = '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"dataSource":{"dataSourceConfig":""},"dataFormat":"","importOptions":{"destinationOptions":"","delimitedTextOptions":""},"clientRequestToken":""}'
};

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 = @{ @"dataSource": @{ @"dataSourceConfig": @"" },
                              @"dataFormat": @"",
                              @"importOptions": @{ @"destinationOptions": @"", @"delimitedTextOptions": @"" },
                              @"clientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'dataSource' => [
        'dataSourceConfig' => ''
    ],
    'dataFormat' => '',
    'importOptions' => [
        'destinationOptions' => '',
        'delimitedTextOptions' => ''
    ],
    'clientRequestToken' => ''
  ]),
  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}}/workbooks/:workbookId/tables/:tableId/import', [
  'body' => '{
  "dataSource": {
    "dataSourceConfig": ""
  },
  "dataFormat": "",
  "importOptions": {
    "destinationOptions": "",
    "delimitedTextOptions": ""
  },
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'dataSource' => [
    'dataSourceConfig' => ''
  ],
  'dataFormat' => '',
  'importOptions' => [
    'destinationOptions' => '',
    'delimitedTextOptions' => ''
  ],
  'clientRequestToken' => ''
]));

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

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

append(json_encode([
  'dataSource' => [
    'dataSourceConfig' => ''
  ],
  'dataFormat' => '',
  'importOptions' => [
    'destinationOptions' => '',
    'delimitedTextOptions' => ''
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import');
$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}}/workbooks/:workbookId/tables/:tableId/import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "dataSource": {
    "dataSourceConfig": ""
  },
  "dataFormat": "",
  "importOptions": {
    "destinationOptions": "",
    "delimitedTextOptions": ""
  },
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "dataSource": {
    "dataSourceConfig": ""
  },
  "dataFormat": "",
  "importOptions": {
    "destinationOptions": "",
    "delimitedTextOptions": ""
  },
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/workbooks/:workbookId/tables/:tableId/import", payload, headers)

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

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

import requests

url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import"

payload = {
    "dataSource": { "dataSourceConfig": "" },
    "dataFormat": "",
    "importOptions": {
        "destinationOptions": "",
        "delimitedTextOptions": ""
    },
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import"

payload <- "{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\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}}/workbooks/:workbookId/tables/:tableId/import")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\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/workbooks/:workbookId/tables/:tableId/import') do |req|
  req.body = "{\n  \"dataSource\": {\n    \"dataSourceConfig\": \"\"\n  },\n  \"dataFormat\": \"\",\n  \"importOptions\": {\n    \"destinationOptions\": \"\",\n    \"delimitedTextOptions\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/workbooks/:workbookId/tables/:tableId/import";

    let payload = json!({
        "dataSource": json!({"dataSourceConfig": ""}),
        "dataFormat": "",
        "importOptions": json!({
            "destinationOptions": "",
            "delimitedTextOptions": ""
        }),
        "clientRequestToken": ""
    });

    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}}/workbooks/:workbookId/tables/:tableId/import \
  --header 'content-type: application/json' \
  --data '{
  "dataSource": {
    "dataSourceConfig": ""
  },
  "dataFormat": "",
  "importOptions": {
    "destinationOptions": "",
    "delimitedTextOptions": ""
  },
  "clientRequestToken": ""
}'

echo '{
  "dataSource": {
    "dataSourceConfig": ""
  },
  "dataFormat": "",
  "importOptions": {
    "destinationOptions": "",
    "delimitedTextOptions": ""
  },
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/workbooks/:workbookId/tables/:tableId/import \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "dataSource": {\n    "dataSourceConfig": ""\n  },\n  "dataFormat": "",\n  "importOptions": {\n    "destinationOptions": "",\n    "delimitedTextOptions": ""\n  },\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/workbooks/:workbookId/tables/:tableId/import

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "dataSource": ["dataSourceConfig": ""],
  "dataFormat": "",
  "importOptions": [
    "destinationOptions": "",
    "delimitedTextOptions": ""
  ],
  "clientRequestToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST TagResource

{{baseUrl}}/tags/:resourceArn

QUERY PARAMS

resourceArn

BODY json

{
  "tags": {}
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/tags/:resourceArn" {:content-type :json
                                                              :form-params {:tags {}}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tags\": {}\n}"

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

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

var client = new RestClient("{{baseUrl}}/tags/:resourceArn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tags/:resourceArn"

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

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

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

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

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

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

}

POST /baseUrl/tags/:resourceArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "tags": {}
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/tags/:resourceArn")
  .header("content-type", "application/json")
  .body("{\n  \"tags\": {}\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

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

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  body: {tags: {}},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/tags/:resourceArn');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

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

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

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/tags/:resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'tags' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/tags/:resourceArn', [
  'body' => '{
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/tags/:resourceArn');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

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

import http.client

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

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

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

conn.request("POST", "/baseUrl/tags/:resourceArn", payload, headers)

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

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

import requests

url = "{{baseUrl}}/tags/:resourceArn"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

payload <- "{\n  \"tags\": {}\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/tags/:resourceArn') do |req|
  req.body = "{\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/tags/:resourceArn \
  --header 'content-type: application/json' \
  --data '{
  "tags": {}
}'

echo '{
  "tags": {}
}' |  \
  http POST {{baseUrl}}/tags/:resourceArn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

import Foundation

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

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

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

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

dataTask.resume()

DELETE UntagResource

{{baseUrl}}/tags/:resourceArn#tagKeys

QUERY PARAMS

tagKeys

resourceArn

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/tags/:resourceArn#tagKeys" {:query-params {:tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"

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

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

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

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

}

DELETE /baseUrl/tags/:resourceArn?tagKeys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

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

const url = '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn?tagKeys=',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  qs: {tagKeys: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tags/:resourceArn#tagKeys');

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

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

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

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

const url = '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys" in

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

 "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn#tagKeys');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

setRequestUrl('{{baseUrl}}/tags/:resourceArn#tagKeys');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'tagKeys' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/tags/:resourceArn?tagKeys=")

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

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

import requests

url = "{{baseUrl}}/tags/:resourceArn#tagKeys"

querystring = {"tagKeys":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn#tagKeys"

queryString <- list(tagKeys = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/tags/:resourceArn') do |req|
  req.params['tagKeys'] = ''
end

puts response.status
puts response.body

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

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

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

http DELETE '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

Amazon Honeycodev2020-03-01

Related APIs