Dataform API

GET dataform.projects.locations.list

{{baseUrl}}/v1beta1/:name/locations

QUERY PARAMS

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name/locations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:name/locations")

require "http/client"

url = "{{baseUrl}}/v1beta1/:name/locations"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:name/locations"

	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/v1beta1/:name/locations HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta1/:name/locations'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name/locations")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:name/locations');

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}}/v1beta1/:name/locations'};

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

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

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

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

 "{{baseUrl}}/v1beta1/:name/locations",
  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}}/v1beta1/:name/locations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:name/locations');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:name/locations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name/locations' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:name/locations")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:name/locations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name/locations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:name/locations")

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/v1beta1/:name/locations') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:name/locations

http GET {{baseUrl}}/v1beta1/:name/locations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:name/locations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:name/locations")! 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 dataform.projects.locations.repositories.compilationResults.create

{{baseUrl}}/v1beta1/:parent/compilationResults

QUERY PARAMS

parent

BODY json

{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "compilationErrors": [
    {
      "actionTarget": {
        "database": "",
        "name": "",
        "schema": ""
      },
      "message": "",
      "path": "",
      "stack": ""
    }
  ],
  "dataformCoreVersion": "",
  "gitCommitish": "",
  "name": "",
  "releaseConfig": "",
  "resolvedGitCommitSha": "",
  "workspace": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/compilationResults");

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  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:parent/compilationResults" {:content-type :json
                                                                               :form-params {:codeCompilationConfig {:assertionSchema ""
                                                                                                                     :databaseSuffix ""
                                                                                                                     :defaultDatabase ""
                                                                                                                     :defaultLocation ""
                                                                                                                     :defaultSchema ""
                                                                                                                     :schemaSuffix ""
                                                                                                                     :tablePrefix ""
                                                                                                                     :vars {}}
                                                                                             :compilationErrors [{:actionTarget {:database ""
                                                                                                                                 :name ""
                                                                                                                                 :schema ""}
                                                                                                                  :message ""
                                                                                                                  :path ""
                                                                                                                  :stack ""}]
                                                                                             :dataformCoreVersion ""
                                                                                             :gitCommitish ""
                                                                                             :name ""
                                                                                             :releaseConfig ""
                                                                                             :resolvedGitCommitSha ""
                                                                                             :workspace ""}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/compilationResults"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\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}}/v1beta1/:parent/compilationResults"),
    Content = new StringContent("{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\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}}/v1beta1/:parent/compilationResults");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/compilationResults"

	payload := strings.NewReader("{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\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/v1beta1/:parent/compilationResults HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 564

{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "compilationErrors": [
    {
      "actionTarget": {
        "database": "",
        "name": "",
        "schema": ""
      },
      "message": "",
      "path": "",
      "stack": ""
    }
  ],
  "dataformCoreVersion": "",
  "gitCommitish": "",
  "name": "",
  "releaseConfig": "",
  "resolvedGitCommitSha": "",
  "workspace": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:parent/compilationResults")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:parent/compilationResults"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\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  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/compilationResults")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:parent/compilationResults")
  .header("content-type", "application/json")
  .body("{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  codeCompilationConfig: {
    assertionSchema: '',
    databaseSuffix: '',
    defaultDatabase: '',
    defaultLocation: '',
    defaultSchema: '',
    schemaSuffix: '',
    tablePrefix: '',
    vars: {}
  },
  compilationErrors: [
    {
      actionTarget: {
        database: '',
        name: '',
        schema: ''
      },
      message: '',
      path: '',
      stack: ''
    }
  ],
  dataformCoreVersion: '',
  gitCommitish: '',
  name: '',
  releaseConfig: '',
  resolvedGitCommitSha: '',
  workspace: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:parent/compilationResults');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/compilationResults',
  headers: {'content-type': 'application/json'},
  data: {
    codeCompilationConfig: {
      assertionSchema: '',
      databaseSuffix: '',
      defaultDatabase: '',
      defaultLocation: '',
      defaultSchema: '',
      schemaSuffix: '',
      tablePrefix: '',
      vars: {}
    },
    compilationErrors: [
      {
        actionTarget: {database: '', name: '', schema: ''},
        message: '',
        path: '',
        stack: ''
      }
    ],
    dataformCoreVersion: '',
    gitCommitish: '',
    name: '',
    releaseConfig: '',
    resolvedGitCommitSha: '',
    workspace: ''
  }
};

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

const url = '{{baseUrl}}/v1beta1/:parent/compilationResults';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"codeCompilationConfig":{"assertionSchema":"","databaseSuffix":"","defaultDatabase":"","defaultLocation":"","defaultSchema":"","schemaSuffix":"","tablePrefix":"","vars":{}},"compilationErrors":[{"actionTarget":{"database":"","name":"","schema":""},"message":"","path":"","stack":""}],"dataformCoreVersion":"","gitCommitish":"","name":"","releaseConfig":"","resolvedGitCommitSha":"","workspace":""}'
};

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}}/v1beta1/:parent/compilationResults',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "codeCompilationConfig": {\n    "assertionSchema": "",\n    "databaseSuffix": "",\n    "defaultDatabase": "",\n    "defaultLocation": "",\n    "defaultSchema": "",\n    "schemaSuffix": "",\n    "tablePrefix": "",\n    "vars": {}\n  },\n  "compilationErrors": [\n    {\n      "actionTarget": {\n        "database": "",\n        "name": "",\n        "schema": ""\n      },\n      "message": "",\n      "path": "",\n      "stack": ""\n    }\n  ],\n  "dataformCoreVersion": "",\n  "gitCommitish": "",\n  "name": "",\n  "releaseConfig": "",\n  "resolvedGitCommitSha": "",\n  "workspace": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/compilationResults")
  .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/v1beta1/:parent/compilationResults',
  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({
  codeCompilationConfig: {
    assertionSchema: '',
    databaseSuffix: '',
    defaultDatabase: '',
    defaultLocation: '',
    defaultSchema: '',
    schemaSuffix: '',
    tablePrefix: '',
    vars: {}
  },
  compilationErrors: [
    {
      actionTarget: {database: '', name: '', schema: ''},
      message: '',
      path: '',
      stack: ''
    }
  ],
  dataformCoreVersion: '',
  gitCommitish: '',
  name: '',
  releaseConfig: '',
  resolvedGitCommitSha: '',
  workspace: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/compilationResults',
  headers: {'content-type': 'application/json'},
  body: {
    codeCompilationConfig: {
      assertionSchema: '',
      databaseSuffix: '',
      defaultDatabase: '',
      defaultLocation: '',
      defaultSchema: '',
      schemaSuffix: '',
      tablePrefix: '',
      vars: {}
    },
    compilationErrors: [
      {
        actionTarget: {database: '', name: '', schema: ''},
        message: '',
        path: '',
        stack: ''
      }
    ],
    dataformCoreVersion: '',
    gitCommitish: '',
    name: '',
    releaseConfig: '',
    resolvedGitCommitSha: '',
    workspace: ''
  },
  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}}/v1beta1/:parent/compilationResults');

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

req.type('json');
req.send({
  codeCompilationConfig: {
    assertionSchema: '',
    databaseSuffix: '',
    defaultDatabase: '',
    defaultLocation: '',
    defaultSchema: '',
    schemaSuffix: '',
    tablePrefix: '',
    vars: {}
  },
  compilationErrors: [
    {
      actionTarget: {
        database: '',
        name: '',
        schema: ''
      },
      message: '',
      path: '',
      stack: ''
    }
  ],
  dataformCoreVersion: '',
  gitCommitish: '',
  name: '',
  releaseConfig: '',
  resolvedGitCommitSha: '',
  workspace: ''
});

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}}/v1beta1/:parent/compilationResults',
  headers: {'content-type': 'application/json'},
  data: {
    codeCompilationConfig: {
      assertionSchema: '',
      databaseSuffix: '',
      defaultDatabase: '',
      defaultLocation: '',
      defaultSchema: '',
      schemaSuffix: '',
      tablePrefix: '',
      vars: {}
    },
    compilationErrors: [
      {
        actionTarget: {database: '', name: '', schema: ''},
        message: '',
        path: '',
        stack: ''
      }
    ],
    dataformCoreVersion: '',
    gitCommitish: '',
    name: '',
    releaseConfig: '',
    resolvedGitCommitSha: '',
    workspace: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta1/:parent/compilationResults';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"codeCompilationConfig":{"assertionSchema":"","databaseSuffix":"","defaultDatabase":"","defaultLocation":"","defaultSchema":"","schemaSuffix":"","tablePrefix":"","vars":{}},"compilationErrors":[{"actionTarget":{"database":"","name":"","schema":""},"message":"","path":"","stack":""}],"dataformCoreVersion":"","gitCommitish":"","name":"","releaseConfig":"","resolvedGitCommitSha":"","workspace":""}'
};

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 = @{ @"codeCompilationConfig": @{ @"assertionSchema": @"", @"databaseSuffix": @"", @"defaultDatabase": @"", @"defaultLocation": @"", @"defaultSchema": @"", @"schemaSuffix": @"", @"tablePrefix": @"", @"vars": @{  } },
                              @"compilationErrors": @[ @{ @"actionTarget": @{ @"database": @"", @"name": @"", @"schema": @"" }, @"message": @"", @"path": @"", @"stack": @"" } ],
                              @"dataformCoreVersion": @"",
                              @"gitCommitish": @"",
                              @"name": @"",
                              @"releaseConfig": @"",
                              @"resolvedGitCommitSha": @"",
                              @"workspace": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:parent/compilationResults"]
                                                       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}}/v1beta1/:parent/compilationResults" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta1/:parent/compilationResults",
  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([
    'codeCompilationConfig' => [
        'assertionSchema' => '',
        'databaseSuffix' => '',
        'defaultDatabase' => '',
        'defaultLocation' => '',
        'defaultSchema' => '',
        'schemaSuffix' => '',
        'tablePrefix' => '',
        'vars' => [
                
        ]
    ],
    'compilationErrors' => [
        [
                'actionTarget' => [
                                'database' => '',
                                'name' => '',
                                'schema' => ''
                ],
                'message' => '',
                'path' => '',
                'stack' => ''
        ]
    ],
    'dataformCoreVersion' => '',
    'gitCommitish' => '',
    'name' => '',
    'releaseConfig' => '',
    'resolvedGitCommitSha' => '',
    'workspace' => ''
  ]),
  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}}/v1beta1/:parent/compilationResults', [
  'body' => '{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "compilationErrors": [
    {
      "actionTarget": {
        "database": "",
        "name": "",
        "schema": ""
      },
      "message": "",
      "path": "",
      "stack": ""
    }
  ],
  "dataformCoreVersion": "",
  "gitCommitish": "",
  "name": "",
  "releaseConfig": "",
  "resolvedGitCommitSha": "",
  "workspace": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/compilationResults');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'codeCompilationConfig' => [
    'assertionSchema' => '',
    'databaseSuffix' => '',
    'defaultDatabase' => '',
    'defaultLocation' => '',
    'defaultSchema' => '',
    'schemaSuffix' => '',
    'tablePrefix' => '',
    'vars' => [
        
    ]
  ],
  'compilationErrors' => [
    [
        'actionTarget' => [
                'database' => '',
                'name' => '',
                'schema' => ''
        ],
        'message' => '',
        'path' => '',
        'stack' => ''
    ]
  ],
  'dataformCoreVersion' => '',
  'gitCommitish' => '',
  'name' => '',
  'releaseConfig' => '',
  'resolvedGitCommitSha' => '',
  'workspace' => ''
]));

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

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

append(json_encode([
  'codeCompilationConfig' => [
    'assertionSchema' => '',
    'databaseSuffix' => '',
    'defaultDatabase' => '',
    'defaultLocation' => '',
    'defaultSchema' => '',
    'schemaSuffix' => '',
    'tablePrefix' => '',
    'vars' => [
        
    ]
  ],
  'compilationErrors' => [
    [
        'actionTarget' => [
                'database' => '',
                'name' => '',
                'schema' => ''
        ],
        'message' => '',
        'path' => '',
        'stack' => ''
    ]
  ],
  'dataformCoreVersion' => '',
  'gitCommitish' => '',
  'name' => '',
  'releaseConfig' => '',
  'resolvedGitCommitSha' => '',
  'workspace' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:parent/compilationResults');
$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}}/v1beta1/:parent/compilationResults' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "compilationErrors": [
    {
      "actionTarget": {
        "database": "",
        "name": "",
        "schema": ""
      },
      "message": "",
      "path": "",
      "stack": ""
    }
  ],
  "dataformCoreVersion": "",
  "gitCommitish": "",
  "name": "",
  "releaseConfig": "",
  "resolvedGitCommitSha": "",
  "workspace": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/compilationResults' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "compilationErrors": [
    {
      "actionTarget": {
        "database": "",
        "name": "",
        "schema": ""
      },
      "message": "",
      "path": "",
      "stack": ""
    }
  ],
  "dataformCoreVersion": "",
  "gitCommitish": "",
  "name": "",
  "releaseConfig": "",
  "resolvedGitCommitSha": "",
  "workspace": ""
}'

import http.client

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

payload = "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta1/:parent/compilationResults", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/compilationResults"

payload = {
    "codeCompilationConfig": {
        "assertionSchema": "",
        "databaseSuffix": "",
        "defaultDatabase": "",
        "defaultLocation": "",
        "defaultSchema": "",
        "schemaSuffix": "",
        "tablePrefix": "",
        "vars": {}
    },
    "compilationErrors": [
        {
            "actionTarget": {
                "database": "",
                "name": "",
                "schema": ""
            },
            "message": "",
            "path": "",
            "stack": ""
        }
    ],
    "dataformCoreVersion": "",
    "gitCommitish": "",
    "name": "",
    "releaseConfig": "",
    "resolvedGitCommitSha": "",
    "workspace": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/compilationResults"

payload <- "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\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}}/v1beta1/:parent/compilationResults")

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  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\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/v1beta1/:parent/compilationResults') do |req|
  req.body = "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"compilationErrors\": [\n    {\n      \"actionTarget\": {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      },\n      \"message\": \"\",\n      \"path\": \"\",\n      \"stack\": \"\"\n    }\n  ],\n  \"dataformCoreVersion\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"releaseConfig\": \"\",\n  \"resolvedGitCommitSha\": \"\",\n  \"workspace\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "codeCompilationConfig": json!({
            "assertionSchema": "",
            "databaseSuffix": "",
            "defaultDatabase": "",
            "defaultLocation": "",
            "defaultSchema": "",
            "schemaSuffix": "",
            "tablePrefix": "",
            "vars": json!({})
        }),
        "compilationErrors": (
            json!({
                "actionTarget": json!({
                    "database": "",
                    "name": "",
                    "schema": ""
                }),
                "message": "",
                "path": "",
                "stack": ""
            })
        ),
        "dataformCoreVersion": "",
        "gitCommitish": "",
        "name": "",
        "releaseConfig": "",
        "resolvedGitCommitSha": "",
        "workspace": ""
    });

    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}}/v1beta1/:parent/compilationResults \
  --header 'content-type: application/json' \
  --data '{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "compilationErrors": [
    {
      "actionTarget": {
        "database": "",
        "name": "",
        "schema": ""
      },
      "message": "",
      "path": "",
      "stack": ""
    }
  ],
  "dataformCoreVersion": "",
  "gitCommitish": "",
  "name": "",
  "releaseConfig": "",
  "resolvedGitCommitSha": "",
  "workspace": ""
}'

echo '{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "compilationErrors": [
    {
      "actionTarget": {
        "database": "",
        "name": "",
        "schema": ""
      },
      "message": "",
      "path": "",
      "stack": ""
    }
  ],
  "dataformCoreVersion": "",
  "gitCommitish": "",
  "name": "",
  "releaseConfig": "",
  "resolvedGitCommitSha": "",
  "workspace": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:parent/compilationResults \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "codeCompilationConfig": {\n    "assertionSchema": "",\n    "databaseSuffix": "",\n    "defaultDatabase": "",\n    "defaultLocation": "",\n    "defaultSchema": "",\n    "schemaSuffix": "",\n    "tablePrefix": "",\n    "vars": {}\n  },\n  "compilationErrors": [\n    {\n      "actionTarget": {\n        "database": "",\n        "name": "",\n        "schema": ""\n      },\n      "message": "",\n      "path": "",\n      "stack": ""\n    }\n  ],\n  "dataformCoreVersion": "",\n  "gitCommitish": "",\n  "name": "",\n  "releaseConfig": "",\n  "resolvedGitCommitSha": "",\n  "workspace": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/compilationResults

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "codeCompilationConfig": [
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": []
  ],
  "compilationErrors": [
    [
      "actionTarget": [
        "database": "",
        "name": "",
        "schema": ""
      ],
      "message": "",
      "path": "",
      "stack": ""
    ]
  ],
  "dataformCoreVersion": "",
  "gitCommitish": "",
  "name": "",
  "releaseConfig": "",
  "resolvedGitCommitSha": "",
  "workspace": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:parent/compilationResults")! 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 dataform.projects.locations.repositories.compilationResults.list

{{baseUrl}}/v1beta1/:parent/compilationResults

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/compilationResults");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:parent/compilationResults")

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/compilationResults"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/compilationResults"

	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/v1beta1/:parent/compilationResults HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta1/:parent/compilationResults'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/compilationResults")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:parent/compilationResults');

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}}/v1beta1/:parent/compilationResults'
};

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

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

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

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

 "{{baseUrl}}/v1beta1/:parent/compilationResults",
  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}}/v1beta1/:parent/compilationResults');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/compilationResults');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:parent/compilationResults' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/compilationResults' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:parent/compilationResults")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/compilationResults"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/compilationResults"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:parent/compilationResults")

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/v1beta1/:parent/compilationResults') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:parent/compilationResults

http GET {{baseUrl}}/v1beta1/:parent/compilationResults

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/compilationResults

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:parent/compilationResults")! 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 dataform.projects.locations.repositories.create

{{baseUrl}}/v1beta1/:parent/repositories

QUERY PARAMS

parent

BODY json

{
  "gitRemoteSettings": {
    "authenticationTokenSecretVersion": "",
    "defaultBranch": "",
    "tokenStatus": "",
    "url": ""
  },
  "name": "",
  "npmrcEnvironmentVariablesSecretVersion": "",
  "workspaceCompilationOverrides": {
    "defaultDatabase": "",
    "schemaSuffix": "",
    "tablePrefix": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/repositories");

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  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:parent/repositories" {:content-type :json
                                                                         :form-params {:gitRemoteSettings {:authenticationTokenSecretVersion ""
                                                                                                           :defaultBranch ""
                                                                                                           :tokenStatus ""
                                                                                                           :url ""}
                                                                                       :name ""
                                                                                       :npmrcEnvironmentVariablesSecretVersion ""
                                                                                       :workspaceCompilationOverrides {:defaultDatabase ""
                                                                                                                       :schemaSuffix ""
                                                                                                                       :tablePrefix ""}}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/repositories"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1beta1/:parent/repositories"),
    Content = new StringContent("{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta1/:parent/repositories");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/repositories"

	payload := strings.NewReader("{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}")

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

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

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

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

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

}

POST /baseUrl/v1beta1/:parent/repositories HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 315

{
  "gitRemoteSettings": {
    "authenticationTokenSecretVersion": "",
    "defaultBranch": "",
    "tokenStatus": "",
    "url": ""
  },
  "name": "",
  "npmrcEnvironmentVariablesSecretVersion": "",
  "workspaceCompilationOverrides": {
    "defaultDatabase": "",
    "schemaSuffix": "",
    "tablePrefix": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:parent/repositories")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:parent/repositories"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/repositories")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:parent/repositories")
  .header("content-type", "application/json")
  .body("{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  gitRemoteSettings: {
    authenticationTokenSecretVersion: '',
    defaultBranch: '',
    tokenStatus: '',
    url: ''
  },
  name: '',
  npmrcEnvironmentVariablesSecretVersion: '',
  workspaceCompilationOverrides: {
    defaultDatabase: '',
    schemaSuffix: '',
    tablePrefix: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:parent/repositories');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/repositories',
  headers: {'content-type': 'application/json'},
  data: {
    gitRemoteSettings: {
      authenticationTokenSecretVersion: '',
      defaultBranch: '',
      tokenStatus: '',
      url: ''
    },
    name: '',
    npmrcEnvironmentVariablesSecretVersion: '',
    workspaceCompilationOverrides: {defaultDatabase: '', schemaSuffix: '', tablePrefix: ''}
  }
};

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

const url = '{{baseUrl}}/v1beta1/:parent/repositories';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"gitRemoteSettings":{"authenticationTokenSecretVersion":"","defaultBranch":"","tokenStatus":"","url":""},"name":"","npmrcEnvironmentVariablesSecretVersion":"","workspaceCompilationOverrides":{"defaultDatabase":"","schemaSuffix":"","tablePrefix":""}}'
};

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}}/v1beta1/:parent/repositories',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "gitRemoteSettings": {\n    "authenticationTokenSecretVersion": "",\n    "defaultBranch": "",\n    "tokenStatus": "",\n    "url": ""\n  },\n  "name": "",\n  "npmrcEnvironmentVariablesSecretVersion": "",\n  "workspaceCompilationOverrides": {\n    "defaultDatabase": "",\n    "schemaSuffix": "",\n    "tablePrefix": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/repositories")
  .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/v1beta1/:parent/repositories',
  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({
  gitRemoteSettings: {
    authenticationTokenSecretVersion: '',
    defaultBranch: '',
    tokenStatus: '',
    url: ''
  },
  name: '',
  npmrcEnvironmentVariablesSecretVersion: '',
  workspaceCompilationOverrides: {defaultDatabase: '', schemaSuffix: '', tablePrefix: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/repositories',
  headers: {'content-type': 'application/json'},
  body: {
    gitRemoteSettings: {
      authenticationTokenSecretVersion: '',
      defaultBranch: '',
      tokenStatus: '',
      url: ''
    },
    name: '',
    npmrcEnvironmentVariablesSecretVersion: '',
    workspaceCompilationOverrides: {defaultDatabase: '', schemaSuffix: '', tablePrefix: ''}
  },
  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}}/v1beta1/:parent/repositories');

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

req.type('json');
req.send({
  gitRemoteSettings: {
    authenticationTokenSecretVersion: '',
    defaultBranch: '',
    tokenStatus: '',
    url: ''
  },
  name: '',
  npmrcEnvironmentVariablesSecretVersion: '',
  workspaceCompilationOverrides: {
    defaultDatabase: '',
    schemaSuffix: '',
    tablePrefix: ''
  }
});

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}}/v1beta1/:parent/repositories',
  headers: {'content-type': 'application/json'},
  data: {
    gitRemoteSettings: {
      authenticationTokenSecretVersion: '',
      defaultBranch: '',
      tokenStatus: '',
      url: ''
    },
    name: '',
    npmrcEnvironmentVariablesSecretVersion: '',
    workspaceCompilationOverrides: {defaultDatabase: '', schemaSuffix: '', tablePrefix: ''}
  }
};

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

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

const url = '{{baseUrl}}/v1beta1/:parent/repositories';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"gitRemoteSettings":{"authenticationTokenSecretVersion":"","defaultBranch":"","tokenStatus":"","url":""},"name":"","npmrcEnvironmentVariablesSecretVersion":"","workspaceCompilationOverrides":{"defaultDatabase":"","schemaSuffix":"","tablePrefix":""}}'
};

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 = @{ @"gitRemoteSettings": @{ @"authenticationTokenSecretVersion": @"", @"defaultBranch": @"", @"tokenStatus": @"", @"url": @"" },
                              @"name": @"",
                              @"npmrcEnvironmentVariablesSecretVersion": @"",
                              @"workspaceCompilationOverrides": @{ @"defaultDatabase": @"", @"schemaSuffix": @"", @"tablePrefix": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:parent/repositories"]
                                                       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}}/v1beta1/:parent/repositories" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1beta1/:parent/repositories",
  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([
    'gitRemoteSettings' => [
        'authenticationTokenSecretVersion' => '',
        'defaultBranch' => '',
        'tokenStatus' => '',
        'url' => ''
    ],
    'name' => '',
    'npmrcEnvironmentVariablesSecretVersion' => '',
    'workspaceCompilationOverrides' => [
        'defaultDatabase' => '',
        'schemaSuffix' => '',
        'tablePrefix' => ''
    ]
  ]),
  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}}/v1beta1/:parent/repositories', [
  'body' => '{
  "gitRemoteSettings": {
    "authenticationTokenSecretVersion": "",
    "defaultBranch": "",
    "tokenStatus": "",
    "url": ""
  },
  "name": "",
  "npmrcEnvironmentVariablesSecretVersion": "",
  "workspaceCompilationOverrides": {
    "defaultDatabase": "",
    "schemaSuffix": "",
    "tablePrefix": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/repositories');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'gitRemoteSettings' => [
    'authenticationTokenSecretVersion' => '',
    'defaultBranch' => '',
    'tokenStatus' => '',
    'url' => ''
  ],
  'name' => '',
  'npmrcEnvironmentVariablesSecretVersion' => '',
  'workspaceCompilationOverrides' => [
    'defaultDatabase' => '',
    'schemaSuffix' => '',
    'tablePrefix' => ''
  ]
]));

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

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

append(json_encode([
  'gitRemoteSettings' => [
    'authenticationTokenSecretVersion' => '',
    'defaultBranch' => '',
    'tokenStatus' => '',
    'url' => ''
  ],
  'name' => '',
  'npmrcEnvironmentVariablesSecretVersion' => '',
  'workspaceCompilationOverrides' => [
    'defaultDatabase' => '',
    'schemaSuffix' => '',
    'tablePrefix' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:parent/repositories');
$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}}/v1beta1/:parent/repositories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "gitRemoteSettings": {
    "authenticationTokenSecretVersion": "",
    "defaultBranch": "",
    "tokenStatus": "",
    "url": ""
  },
  "name": "",
  "npmrcEnvironmentVariablesSecretVersion": "",
  "workspaceCompilationOverrides": {
    "defaultDatabase": "",
    "schemaSuffix": "",
    "tablePrefix": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/repositories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "gitRemoteSettings": {
    "authenticationTokenSecretVersion": "",
    "defaultBranch": "",
    "tokenStatus": "",
    "url": ""
  },
  "name": "",
  "npmrcEnvironmentVariablesSecretVersion": "",
  "workspaceCompilationOverrides": {
    "defaultDatabase": "",
    "schemaSuffix": "",
    "tablePrefix": ""
  }
}'

import http.client

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

payload = "{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1beta1/:parent/repositories", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/repositories"

payload = {
    "gitRemoteSettings": {
        "authenticationTokenSecretVersion": "",
        "defaultBranch": "",
        "tokenStatus": "",
        "url": ""
    },
    "name": "",
    "npmrcEnvironmentVariablesSecretVersion": "",
    "workspaceCompilationOverrides": {
        "defaultDatabase": "",
        "schemaSuffix": "",
        "tablePrefix": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/repositories"

payload <- "{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:parent/repositories")

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  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1beta1/:parent/repositories') do |req|
  req.body = "{\n  \"gitRemoteSettings\": {\n    \"authenticationTokenSecretVersion\": \"\",\n    \"defaultBranch\": \"\",\n    \"tokenStatus\": \"\",\n    \"url\": \"\"\n  },\n  \"name\": \"\",\n  \"npmrcEnvironmentVariablesSecretVersion\": \"\",\n  \"workspaceCompilationOverrides\": {\n    \"defaultDatabase\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "gitRemoteSettings": json!({
            "authenticationTokenSecretVersion": "",
            "defaultBranch": "",
            "tokenStatus": "",
            "url": ""
        }),
        "name": "",
        "npmrcEnvironmentVariablesSecretVersion": "",
        "workspaceCompilationOverrides": json!({
            "defaultDatabase": "",
            "schemaSuffix": "",
            "tablePrefix": ""
        })
    });

    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}}/v1beta1/:parent/repositories \
  --header 'content-type: application/json' \
  --data '{
  "gitRemoteSettings": {
    "authenticationTokenSecretVersion": "",
    "defaultBranch": "",
    "tokenStatus": "",
    "url": ""
  },
  "name": "",
  "npmrcEnvironmentVariablesSecretVersion": "",
  "workspaceCompilationOverrides": {
    "defaultDatabase": "",
    "schemaSuffix": "",
    "tablePrefix": ""
  }
}'

echo '{
  "gitRemoteSettings": {
    "authenticationTokenSecretVersion": "",
    "defaultBranch": "",
    "tokenStatus": "",
    "url": ""
  },
  "name": "",
  "npmrcEnvironmentVariablesSecretVersion": "",
  "workspaceCompilationOverrides": {
    "defaultDatabase": "",
    "schemaSuffix": "",
    "tablePrefix": ""
  }
}' |  \
  http POST {{baseUrl}}/v1beta1/:parent/repositories \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "gitRemoteSettings": {\n    "authenticationTokenSecretVersion": "",\n    "defaultBranch": "",\n    "tokenStatus": "",\n    "url": ""\n  },\n  "name": "",\n  "npmrcEnvironmentVariablesSecretVersion": "",\n  "workspaceCompilationOverrides": {\n    "defaultDatabase": "",\n    "schemaSuffix": "",\n    "tablePrefix": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/repositories

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "gitRemoteSettings": [
    "authenticationTokenSecretVersion": "",
    "defaultBranch": "",
    "tokenStatus": "",
    "url": ""
  ],
  "name": "",
  "npmrcEnvironmentVariablesSecretVersion": "",
  "workspaceCompilationOverrides": [
    "defaultDatabase": "",
    "schemaSuffix": "",
    "tablePrefix": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:parent/repositories")! 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 dataform.projects.locations.repositories.fetchRemoteBranches

{{baseUrl}}/v1beta1/:name:fetchRemoteBranches

QUERY PARAMS

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name:fetchRemoteBranches");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:name:fetchRemoteBranches")

require "http/client"

url = "{{baseUrl}}/v1beta1/:name:fetchRemoteBranches"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:name:fetchRemoteBranches"

	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/v1beta1/:name:fetchRemoteBranches HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta1/:name:fetchRemoteBranches'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:fetchRemoteBranches")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:name:fetchRemoteBranches');

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}}/v1beta1/:name:fetchRemoteBranches'
};

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

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

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

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

 "{{baseUrl}}/v1beta1/:name:fetchRemoteBranches",
  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}}/v1beta1/:name:fetchRemoteBranches');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:name:fetchRemoteBranches');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:name:fetchRemoteBranches' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name:fetchRemoteBranches' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:name:fetchRemoteBranches")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:name:fetchRemoteBranches"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name:fetchRemoteBranches"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:name:fetchRemoteBranches")

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/v1beta1/:name:fetchRemoteBranches') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:name:fetchRemoteBranches

http GET {{baseUrl}}/v1beta1/:name:fetchRemoteBranches

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:name:fetchRemoteBranches

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:name:fetchRemoteBranches")! 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 dataform.projects.locations.repositories.list

{{baseUrl}}/v1beta1/:parent/repositories

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/repositories");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:parent/repositories")

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/repositories"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/repositories"

	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/v1beta1/:parent/repositories HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta1/:parent/repositories'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/repositories")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:parent/repositories');

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}}/v1beta1/:parent/repositories'};

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

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

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

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

 "{{baseUrl}}/v1beta1/:parent/repositories",
  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}}/v1beta1/:parent/repositories');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/repositories');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:parent/repositories' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/repositories' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:parent/repositories")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/repositories"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/repositories"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:parent/repositories")

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/v1beta1/:parent/repositories') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:parent/repositories

http GET {{baseUrl}}/v1beta1/:parent/repositories

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/repositories

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:parent/repositories")! 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 dataform.projects.locations.repositories.releaseConfigs.create

{{baseUrl}}/v1beta1/:parent/releaseConfigs

QUERY PARAMS

parent

BODY json

{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "cronSchedule": "",
  "gitCommitish": "",
  "name": "",
  "recentScheduledReleaseRecords": [
    {
      "compilationResult": "",
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "releaseTime": ""
    }
  ],
  "releaseCompilationResult": "",
  "timeZone": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/releaseConfigs");

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  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:parent/releaseConfigs" {:content-type :json
                                                                           :form-params {:codeCompilationConfig {:assertionSchema ""
                                                                                                                 :databaseSuffix ""
                                                                                                                 :defaultDatabase ""
                                                                                                                 :defaultLocation ""
                                                                                                                 :defaultSchema ""
                                                                                                                 :schemaSuffix ""
                                                                                                                 :tablePrefix ""
                                                                                                                 :vars {}}
                                                                                         :cronSchedule ""
                                                                                         :gitCommitish ""
                                                                                         :name ""
                                                                                         :recentScheduledReleaseRecords [{:compilationResult ""
                                                                                                                          :errorStatus {:code 0
                                                                                                                                        :details [{}]
                                                                                                                                        :message ""}
                                                                                                                          :releaseTime ""}]
                                                                                         :releaseCompilationResult ""
                                                                                         :timeZone ""}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/releaseConfigs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\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}}/v1beta1/:parent/releaseConfigs"),
    Content = new StringContent("{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\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}}/v1beta1/:parent/releaseConfigs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/releaseConfigs"

	payload := strings.NewReader("{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\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/v1beta1/:parent/releaseConfigs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 567

{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "cronSchedule": "",
  "gitCommitish": "",
  "name": "",
  "recentScheduledReleaseRecords": [
    {
      "compilationResult": "",
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "releaseTime": ""
    }
  ],
  "releaseCompilationResult": "",
  "timeZone": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:parent/releaseConfigs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:parent/releaseConfigs"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\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  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/releaseConfigs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:parent/releaseConfigs")
  .header("content-type", "application/json")
  .body("{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  codeCompilationConfig: {
    assertionSchema: '',
    databaseSuffix: '',
    defaultDatabase: '',
    defaultLocation: '',
    defaultSchema: '',
    schemaSuffix: '',
    tablePrefix: '',
    vars: {}
  },
  cronSchedule: '',
  gitCommitish: '',
  name: '',
  recentScheduledReleaseRecords: [
    {
      compilationResult: '',
      errorStatus: {
        code: 0,
        details: [
          {}
        ],
        message: ''
      },
      releaseTime: ''
    }
  ],
  releaseCompilationResult: '',
  timeZone: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:parent/releaseConfigs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/releaseConfigs',
  headers: {'content-type': 'application/json'},
  data: {
    codeCompilationConfig: {
      assertionSchema: '',
      databaseSuffix: '',
      defaultDatabase: '',
      defaultLocation: '',
      defaultSchema: '',
      schemaSuffix: '',
      tablePrefix: '',
      vars: {}
    },
    cronSchedule: '',
    gitCommitish: '',
    name: '',
    recentScheduledReleaseRecords: [
      {
        compilationResult: '',
        errorStatus: {code: 0, details: [{}], message: ''},
        releaseTime: ''
      }
    ],
    releaseCompilationResult: '',
    timeZone: ''
  }
};

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

const url = '{{baseUrl}}/v1beta1/:parent/releaseConfigs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"codeCompilationConfig":{"assertionSchema":"","databaseSuffix":"","defaultDatabase":"","defaultLocation":"","defaultSchema":"","schemaSuffix":"","tablePrefix":"","vars":{}},"cronSchedule":"","gitCommitish":"","name":"","recentScheduledReleaseRecords":[{"compilationResult":"","errorStatus":{"code":0,"details":[{}],"message":""},"releaseTime":""}],"releaseCompilationResult":"","timeZone":""}'
};

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}}/v1beta1/:parent/releaseConfigs',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "codeCompilationConfig": {\n    "assertionSchema": "",\n    "databaseSuffix": "",\n    "defaultDatabase": "",\n    "defaultLocation": "",\n    "defaultSchema": "",\n    "schemaSuffix": "",\n    "tablePrefix": "",\n    "vars": {}\n  },\n  "cronSchedule": "",\n  "gitCommitish": "",\n  "name": "",\n  "recentScheduledReleaseRecords": [\n    {\n      "compilationResult": "",\n      "errorStatus": {\n        "code": 0,\n        "details": [\n          {}\n        ],\n        "message": ""\n      },\n      "releaseTime": ""\n    }\n  ],\n  "releaseCompilationResult": "",\n  "timeZone": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/releaseConfigs")
  .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/v1beta1/:parent/releaseConfigs',
  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({
  codeCompilationConfig: {
    assertionSchema: '',
    databaseSuffix: '',
    defaultDatabase: '',
    defaultLocation: '',
    defaultSchema: '',
    schemaSuffix: '',
    tablePrefix: '',
    vars: {}
  },
  cronSchedule: '',
  gitCommitish: '',
  name: '',
  recentScheduledReleaseRecords: [
    {
      compilationResult: '',
      errorStatus: {code: 0, details: [{}], message: ''},
      releaseTime: ''
    }
  ],
  releaseCompilationResult: '',
  timeZone: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/releaseConfigs',
  headers: {'content-type': 'application/json'},
  body: {
    codeCompilationConfig: {
      assertionSchema: '',
      databaseSuffix: '',
      defaultDatabase: '',
      defaultLocation: '',
      defaultSchema: '',
      schemaSuffix: '',
      tablePrefix: '',
      vars: {}
    },
    cronSchedule: '',
    gitCommitish: '',
    name: '',
    recentScheduledReleaseRecords: [
      {
        compilationResult: '',
        errorStatus: {code: 0, details: [{}], message: ''},
        releaseTime: ''
      }
    ],
    releaseCompilationResult: '',
    timeZone: ''
  },
  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}}/v1beta1/:parent/releaseConfigs');

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

req.type('json');
req.send({
  codeCompilationConfig: {
    assertionSchema: '',
    databaseSuffix: '',
    defaultDatabase: '',
    defaultLocation: '',
    defaultSchema: '',
    schemaSuffix: '',
    tablePrefix: '',
    vars: {}
  },
  cronSchedule: '',
  gitCommitish: '',
  name: '',
  recentScheduledReleaseRecords: [
    {
      compilationResult: '',
      errorStatus: {
        code: 0,
        details: [
          {}
        ],
        message: ''
      },
      releaseTime: ''
    }
  ],
  releaseCompilationResult: '',
  timeZone: ''
});

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}}/v1beta1/:parent/releaseConfigs',
  headers: {'content-type': 'application/json'},
  data: {
    codeCompilationConfig: {
      assertionSchema: '',
      databaseSuffix: '',
      defaultDatabase: '',
      defaultLocation: '',
      defaultSchema: '',
      schemaSuffix: '',
      tablePrefix: '',
      vars: {}
    },
    cronSchedule: '',
    gitCommitish: '',
    name: '',
    recentScheduledReleaseRecords: [
      {
        compilationResult: '',
        errorStatus: {code: 0, details: [{}], message: ''},
        releaseTime: ''
      }
    ],
    releaseCompilationResult: '',
    timeZone: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta1/:parent/releaseConfigs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"codeCompilationConfig":{"assertionSchema":"","databaseSuffix":"","defaultDatabase":"","defaultLocation":"","defaultSchema":"","schemaSuffix":"","tablePrefix":"","vars":{}},"cronSchedule":"","gitCommitish":"","name":"","recentScheduledReleaseRecords":[{"compilationResult":"","errorStatus":{"code":0,"details":[{}],"message":""},"releaseTime":""}],"releaseCompilationResult":"","timeZone":""}'
};

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 = @{ @"codeCompilationConfig": @{ @"assertionSchema": @"", @"databaseSuffix": @"", @"defaultDatabase": @"", @"defaultLocation": @"", @"defaultSchema": @"", @"schemaSuffix": @"", @"tablePrefix": @"", @"vars": @{  } },
                              @"cronSchedule": @"",
                              @"gitCommitish": @"",
                              @"name": @"",
                              @"recentScheduledReleaseRecords": @[ @{ @"compilationResult": @"", @"errorStatus": @{ @"code": @0, @"details": @[ @{  } ], @"message": @"" }, @"releaseTime": @"" } ],
                              @"releaseCompilationResult": @"",
                              @"timeZone": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:parent/releaseConfigs"]
                                                       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}}/v1beta1/:parent/releaseConfigs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta1/:parent/releaseConfigs",
  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([
    'codeCompilationConfig' => [
        'assertionSchema' => '',
        'databaseSuffix' => '',
        'defaultDatabase' => '',
        'defaultLocation' => '',
        'defaultSchema' => '',
        'schemaSuffix' => '',
        'tablePrefix' => '',
        'vars' => [
                
        ]
    ],
    'cronSchedule' => '',
    'gitCommitish' => '',
    'name' => '',
    'recentScheduledReleaseRecords' => [
        [
                'compilationResult' => '',
                'errorStatus' => [
                                'code' => 0,
                                'details' => [
                                                                [
                                                                                                                                
                                                                ]
                                ],
                                'message' => ''
                ],
                'releaseTime' => ''
        ]
    ],
    'releaseCompilationResult' => '',
    'timeZone' => ''
  ]),
  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}}/v1beta1/:parent/releaseConfigs', [
  'body' => '{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "cronSchedule": "",
  "gitCommitish": "",
  "name": "",
  "recentScheduledReleaseRecords": [
    {
      "compilationResult": "",
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "releaseTime": ""
    }
  ],
  "releaseCompilationResult": "",
  "timeZone": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/releaseConfigs');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'codeCompilationConfig' => [
    'assertionSchema' => '',
    'databaseSuffix' => '',
    'defaultDatabase' => '',
    'defaultLocation' => '',
    'defaultSchema' => '',
    'schemaSuffix' => '',
    'tablePrefix' => '',
    'vars' => [
        
    ]
  ],
  'cronSchedule' => '',
  'gitCommitish' => '',
  'name' => '',
  'recentScheduledReleaseRecords' => [
    [
        'compilationResult' => '',
        'errorStatus' => [
                'code' => 0,
                'details' => [
                                [
                                                                
                                ]
                ],
                'message' => ''
        ],
        'releaseTime' => ''
    ]
  ],
  'releaseCompilationResult' => '',
  'timeZone' => ''
]));

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

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

append(json_encode([
  'codeCompilationConfig' => [
    'assertionSchema' => '',
    'databaseSuffix' => '',
    'defaultDatabase' => '',
    'defaultLocation' => '',
    'defaultSchema' => '',
    'schemaSuffix' => '',
    'tablePrefix' => '',
    'vars' => [
        
    ]
  ],
  'cronSchedule' => '',
  'gitCommitish' => '',
  'name' => '',
  'recentScheduledReleaseRecords' => [
    [
        'compilationResult' => '',
        'errorStatus' => [
                'code' => 0,
                'details' => [
                                [
                                                                
                                ]
                ],
                'message' => ''
        ],
        'releaseTime' => ''
    ]
  ],
  'releaseCompilationResult' => '',
  'timeZone' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:parent/releaseConfigs');
$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}}/v1beta1/:parent/releaseConfigs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "cronSchedule": "",
  "gitCommitish": "",
  "name": "",
  "recentScheduledReleaseRecords": [
    {
      "compilationResult": "",
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "releaseTime": ""
    }
  ],
  "releaseCompilationResult": "",
  "timeZone": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/releaseConfigs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "cronSchedule": "",
  "gitCommitish": "",
  "name": "",
  "recentScheduledReleaseRecords": [
    {
      "compilationResult": "",
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "releaseTime": ""
    }
  ],
  "releaseCompilationResult": "",
  "timeZone": ""
}'

import http.client

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

payload = "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta1/:parent/releaseConfigs", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/releaseConfigs"

payload = {
    "codeCompilationConfig": {
        "assertionSchema": "",
        "databaseSuffix": "",
        "defaultDatabase": "",
        "defaultLocation": "",
        "defaultSchema": "",
        "schemaSuffix": "",
        "tablePrefix": "",
        "vars": {}
    },
    "cronSchedule": "",
    "gitCommitish": "",
    "name": "",
    "recentScheduledReleaseRecords": [
        {
            "compilationResult": "",
            "errorStatus": {
                "code": 0,
                "details": [{}],
                "message": ""
            },
            "releaseTime": ""
        }
    ],
    "releaseCompilationResult": "",
    "timeZone": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/releaseConfigs"

payload <- "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\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}}/v1beta1/:parent/releaseConfigs")

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  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\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/v1beta1/:parent/releaseConfigs') do |req|
  req.body = "{\n  \"codeCompilationConfig\": {\n    \"assertionSchema\": \"\",\n    \"databaseSuffix\": \"\",\n    \"defaultDatabase\": \"\",\n    \"defaultLocation\": \"\",\n    \"defaultSchema\": \"\",\n    \"schemaSuffix\": \"\",\n    \"tablePrefix\": \"\",\n    \"vars\": {}\n  },\n  \"cronSchedule\": \"\",\n  \"gitCommitish\": \"\",\n  \"name\": \"\",\n  \"recentScheduledReleaseRecords\": [\n    {\n      \"compilationResult\": \"\",\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"releaseTime\": \"\"\n    }\n  ],\n  \"releaseCompilationResult\": \"\",\n  \"timeZone\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "codeCompilationConfig": json!({
            "assertionSchema": "",
            "databaseSuffix": "",
            "defaultDatabase": "",
            "defaultLocation": "",
            "defaultSchema": "",
            "schemaSuffix": "",
            "tablePrefix": "",
            "vars": json!({})
        }),
        "cronSchedule": "",
        "gitCommitish": "",
        "name": "",
        "recentScheduledReleaseRecords": (
            json!({
                "compilationResult": "",
                "errorStatus": json!({
                    "code": 0,
                    "details": (json!({})),
                    "message": ""
                }),
                "releaseTime": ""
            })
        ),
        "releaseCompilationResult": "",
        "timeZone": ""
    });

    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}}/v1beta1/:parent/releaseConfigs \
  --header 'content-type: application/json' \
  --data '{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "cronSchedule": "",
  "gitCommitish": "",
  "name": "",
  "recentScheduledReleaseRecords": [
    {
      "compilationResult": "",
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "releaseTime": ""
    }
  ],
  "releaseCompilationResult": "",
  "timeZone": ""
}'

echo '{
  "codeCompilationConfig": {
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": {}
  },
  "cronSchedule": "",
  "gitCommitish": "",
  "name": "",
  "recentScheduledReleaseRecords": [
    {
      "compilationResult": "",
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "releaseTime": ""
    }
  ],
  "releaseCompilationResult": "",
  "timeZone": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:parent/releaseConfigs \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "codeCompilationConfig": {\n    "assertionSchema": "",\n    "databaseSuffix": "",\n    "defaultDatabase": "",\n    "defaultLocation": "",\n    "defaultSchema": "",\n    "schemaSuffix": "",\n    "tablePrefix": "",\n    "vars": {}\n  },\n  "cronSchedule": "",\n  "gitCommitish": "",\n  "name": "",\n  "recentScheduledReleaseRecords": [\n    {\n      "compilationResult": "",\n      "errorStatus": {\n        "code": 0,\n        "details": [\n          {}\n        ],\n        "message": ""\n      },\n      "releaseTime": ""\n    }\n  ],\n  "releaseCompilationResult": "",\n  "timeZone": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/releaseConfigs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "codeCompilationConfig": [
    "assertionSchema": "",
    "databaseSuffix": "",
    "defaultDatabase": "",
    "defaultLocation": "",
    "defaultSchema": "",
    "schemaSuffix": "",
    "tablePrefix": "",
    "vars": []
  ],
  "cronSchedule": "",
  "gitCommitish": "",
  "name": "",
  "recentScheduledReleaseRecords": [
    [
      "compilationResult": "",
      "errorStatus": [
        "code": 0,
        "details": [[]],
        "message": ""
      ],
      "releaseTime": ""
    ]
  ],
  "releaseCompilationResult": "",
  "timeZone": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:parent/releaseConfigs")! 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 dataform.projects.locations.repositories.releaseConfigs.list

{{baseUrl}}/v1beta1/:parent/releaseConfigs

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/releaseConfigs");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:parent/releaseConfigs")

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/releaseConfigs"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/releaseConfigs"

	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/v1beta1/:parent/releaseConfigs HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta1/:parent/releaseConfigs'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/releaseConfigs")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:parent/releaseConfigs');

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}}/v1beta1/:parent/releaseConfigs'
};

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

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

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

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

 "{{baseUrl}}/v1beta1/:parent/releaseConfigs",
  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}}/v1beta1/:parent/releaseConfigs');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/releaseConfigs');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:parent/releaseConfigs' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/releaseConfigs' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:parent/releaseConfigs")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/releaseConfigs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/releaseConfigs"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:parent/releaseConfigs")

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/v1beta1/:parent/releaseConfigs') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:parent/releaseConfigs

http GET {{baseUrl}}/v1beta1/:parent/releaseConfigs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/releaseConfigs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:parent/releaseConfigs")! 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 dataform.projects.locations.repositories.workflowConfigs.create

{{baseUrl}}/v1beta1/:parent/workflowConfigs

QUERY PARAMS

parent

BODY json

{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/workflowConfigs");

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  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:parent/workflowConfigs" {:content-type :json
                                                                            :form-params {:cronSchedule ""
                                                                                          :invocationConfig {:fullyRefreshIncrementalTablesEnabled false
                                                                                                             :includedTags []
                                                                                                             :includedTargets [{:database ""
                                                                                                                                :name ""
                                                                                                                                :schema ""}]
                                                                                                             :transitiveDependenciesIncluded false
                                                                                                             :transitiveDependentsIncluded false}
                                                                                          :name ""
                                                                                          :recentScheduledExecutionRecords [{:errorStatus {:code 0
                                                                                                                                           :details [{}]
                                                                                                                                           :message ""}
                                                                                                                             :executionTime ""
                                                                                                                             :workflowInvocation ""}]
                                                                                          :releaseConfig ""
                                                                                          :timeZone ""}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/workflowConfigs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\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}}/v1beta1/:parent/workflowConfigs"),
    Content = new StringContent("{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\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}}/v1beta1/:parent/workflowConfigs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/workflowConfigs"

	payload := strings.NewReader("{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\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/v1beta1/:parent/workflowConfigs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 615

{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:parent/workflowConfigs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:parent/workflowConfigs"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\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  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/workflowConfigs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:parent/workflowConfigs")
  .header("content-type", "application/json")
  .body("{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cronSchedule: '',
  invocationConfig: {
    fullyRefreshIncrementalTablesEnabled: false,
    includedTags: [],
    includedTargets: [
      {
        database: '',
        name: '',
        schema: ''
      }
    ],
    transitiveDependenciesIncluded: false,
    transitiveDependentsIncluded: false
  },
  name: '',
  recentScheduledExecutionRecords: [
    {
      errorStatus: {
        code: 0,
        details: [
          {}
        ],
        message: ''
      },
      executionTime: '',
      workflowInvocation: ''
    }
  ],
  releaseConfig: '',
  timeZone: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:parent/workflowConfigs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/workflowConfigs',
  headers: {'content-type': 'application/json'},
  data: {
    cronSchedule: '',
    invocationConfig: {
      fullyRefreshIncrementalTablesEnabled: false,
      includedTags: [],
      includedTargets: [{database: '', name: '', schema: ''}],
      transitiveDependenciesIncluded: false,
      transitiveDependentsIncluded: false
    },
    name: '',
    recentScheduledExecutionRecords: [
      {
        errorStatus: {code: 0, details: [{}], message: ''},
        executionTime: '',
        workflowInvocation: ''
      }
    ],
    releaseConfig: '',
    timeZone: ''
  }
};

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

const url = '{{baseUrl}}/v1beta1/:parent/workflowConfigs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"cronSchedule":"","invocationConfig":{"fullyRefreshIncrementalTablesEnabled":false,"includedTags":[],"includedTargets":[{"database":"","name":"","schema":""}],"transitiveDependenciesIncluded":false,"transitiveDependentsIncluded":false},"name":"","recentScheduledExecutionRecords":[{"errorStatus":{"code":0,"details":[{}],"message":""},"executionTime":"","workflowInvocation":""}],"releaseConfig":"","timeZone":""}'
};

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}}/v1beta1/:parent/workflowConfigs',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cronSchedule": "",\n  "invocationConfig": {\n    "fullyRefreshIncrementalTablesEnabled": false,\n    "includedTags": [],\n    "includedTargets": [\n      {\n        "database": "",\n        "name": "",\n        "schema": ""\n      }\n    ],\n    "transitiveDependenciesIncluded": false,\n    "transitiveDependentsIncluded": false\n  },\n  "name": "",\n  "recentScheduledExecutionRecords": [\n    {\n      "errorStatus": {\n        "code": 0,\n        "details": [\n          {}\n        ],\n        "message": ""\n      },\n      "executionTime": "",\n      "workflowInvocation": ""\n    }\n  ],\n  "releaseConfig": "",\n  "timeZone": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/workflowConfigs")
  .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/v1beta1/:parent/workflowConfigs',
  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({
  cronSchedule: '',
  invocationConfig: {
    fullyRefreshIncrementalTablesEnabled: false,
    includedTags: [],
    includedTargets: [{database: '', name: '', schema: ''}],
    transitiveDependenciesIncluded: false,
    transitiveDependentsIncluded: false
  },
  name: '',
  recentScheduledExecutionRecords: [
    {
      errorStatus: {code: 0, details: [{}], message: ''},
      executionTime: '',
      workflowInvocation: ''
    }
  ],
  releaseConfig: '',
  timeZone: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/workflowConfigs',
  headers: {'content-type': 'application/json'},
  body: {
    cronSchedule: '',
    invocationConfig: {
      fullyRefreshIncrementalTablesEnabled: false,
      includedTags: [],
      includedTargets: [{database: '', name: '', schema: ''}],
      transitiveDependenciesIncluded: false,
      transitiveDependentsIncluded: false
    },
    name: '',
    recentScheduledExecutionRecords: [
      {
        errorStatus: {code: 0, details: [{}], message: ''},
        executionTime: '',
        workflowInvocation: ''
      }
    ],
    releaseConfig: '',
    timeZone: ''
  },
  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}}/v1beta1/:parent/workflowConfigs');

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

req.type('json');
req.send({
  cronSchedule: '',
  invocationConfig: {
    fullyRefreshIncrementalTablesEnabled: false,
    includedTags: [],
    includedTargets: [
      {
        database: '',
        name: '',
        schema: ''
      }
    ],
    transitiveDependenciesIncluded: false,
    transitiveDependentsIncluded: false
  },
  name: '',
  recentScheduledExecutionRecords: [
    {
      errorStatus: {
        code: 0,
        details: [
          {}
        ],
        message: ''
      },
      executionTime: '',
      workflowInvocation: ''
    }
  ],
  releaseConfig: '',
  timeZone: ''
});

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}}/v1beta1/:parent/workflowConfigs',
  headers: {'content-type': 'application/json'},
  data: {
    cronSchedule: '',
    invocationConfig: {
      fullyRefreshIncrementalTablesEnabled: false,
      includedTags: [],
      includedTargets: [{database: '', name: '', schema: ''}],
      transitiveDependenciesIncluded: false,
      transitiveDependentsIncluded: false
    },
    name: '',
    recentScheduledExecutionRecords: [
      {
        errorStatus: {code: 0, details: [{}], message: ''},
        executionTime: '',
        workflowInvocation: ''
      }
    ],
    releaseConfig: '',
    timeZone: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta1/:parent/workflowConfigs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"cronSchedule":"","invocationConfig":{"fullyRefreshIncrementalTablesEnabled":false,"includedTags":[],"includedTargets":[{"database":"","name":"","schema":""}],"transitiveDependenciesIncluded":false,"transitiveDependentsIncluded":false},"name":"","recentScheduledExecutionRecords":[{"errorStatus":{"code":0,"details":[{}],"message":""},"executionTime":"","workflowInvocation":""}],"releaseConfig":"","timeZone":""}'
};

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 = @{ @"cronSchedule": @"",
                              @"invocationConfig": @{ @"fullyRefreshIncrementalTablesEnabled": @NO, @"includedTags": @[  ], @"includedTargets": @[ @{ @"database": @"", @"name": @"", @"schema": @"" } ], @"transitiveDependenciesIncluded": @NO, @"transitiveDependentsIncluded": @NO },
                              @"name": @"",
                              @"recentScheduledExecutionRecords": @[ @{ @"errorStatus": @{ @"code": @0, @"details": @[ @{  } ], @"message": @"" }, @"executionTime": @"", @"workflowInvocation": @"" } ],
                              @"releaseConfig": @"",
                              @"timeZone": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:parent/workflowConfigs"]
                                                       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}}/v1beta1/:parent/workflowConfigs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta1/:parent/workflowConfigs",
  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([
    'cronSchedule' => '',
    'invocationConfig' => [
        'fullyRefreshIncrementalTablesEnabled' => null,
        'includedTags' => [
                
        ],
        'includedTargets' => [
                [
                                'database' => '',
                                'name' => '',
                                'schema' => ''
                ]
        ],
        'transitiveDependenciesIncluded' => null,
        'transitiveDependentsIncluded' => null
    ],
    'name' => '',
    'recentScheduledExecutionRecords' => [
        [
                'errorStatus' => [
                                'code' => 0,
                                'details' => [
                                                                [
                                                                                                                                
                                                                ]
                                ],
                                'message' => ''
                ],
                'executionTime' => '',
                'workflowInvocation' => ''
        ]
    ],
    'releaseConfig' => '',
    'timeZone' => ''
  ]),
  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}}/v1beta1/:parent/workflowConfigs', [
  'body' => '{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/workflowConfigs');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cronSchedule' => '',
  'invocationConfig' => [
    'fullyRefreshIncrementalTablesEnabled' => null,
    'includedTags' => [
        
    ],
    'includedTargets' => [
        [
                'database' => '',
                'name' => '',
                'schema' => ''
        ]
    ],
    'transitiveDependenciesIncluded' => null,
    'transitiveDependentsIncluded' => null
  ],
  'name' => '',
  'recentScheduledExecutionRecords' => [
    [
        'errorStatus' => [
                'code' => 0,
                'details' => [
                                [
                                                                
                                ]
                ],
                'message' => ''
        ],
        'executionTime' => '',
        'workflowInvocation' => ''
    ]
  ],
  'releaseConfig' => '',
  'timeZone' => ''
]));

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

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

append(json_encode([
  'cronSchedule' => '',
  'invocationConfig' => [
    'fullyRefreshIncrementalTablesEnabled' => null,
    'includedTags' => [
        
    ],
    'includedTargets' => [
        [
                'database' => '',
                'name' => '',
                'schema' => ''
        ]
    ],
    'transitiveDependenciesIncluded' => null,
    'transitiveDependentsIncluded' => null
  ],
  'name' => '',
  'recentScheduledExecutionRecords' => [
    [
        'errorStatus' => [
                'code' => 0,
                'details' => [
                                [
                                                                
                                ]
                ],
                'message' => ''
        ],
        'executionTime' => '',
        'workflowInvocation' => ''
    ]
  ],
  'releaseConfig' => '',
  'timeZone' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:parent/workflowConfigs');
$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}}/v1beta1/:parent/workflowConfigs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/workflowConfigs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}'

import http.client

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

payload = "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta1/:parent/workflowConfigs", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/workflowConfigs"

payload = {
    "cronSchedule": "",
    "invocationConfig": {
        "fullyRefreshIncrementalTablesEnabled": False,
        "includedTags": [],
        "includedTargets": [
            {
                "database": "",
                "name": "",
                "schema": ""
            }
        ],
        "transitiveDependenciesIncluded": False,
        "transitiveDependentsIncluded": False
    },
    "name": "",
    "recentScheduledExecutionRecords": [
        {
            "errorStatus": {
                "code": 0,
                "details": [{}],
                "message": ""
            },
            "executionTime": "",
            "workflowInvocation": ""
        }
    ],
    "releaseConfig": "",
    "timeZone": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/workflowConfigs"

payload <- "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\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}}/v1beta1/:parent/workflowConfigs")

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  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\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/v1beta1/:parent/workflowConfigs') do |req|
  req.body = "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "cronSchedule": "",
        "invocationConfig": json!({
            "fullyRefreshIncrementalTablesEnabled": false,
            "includedTags": (),
            "includedTargets": (
                json!({
                    "database": "",
                    "name": "",
                    "schema": ""
                })
            ),
            "transitiveDependenciesIncluded": false,
            "transitiveDependentsIncluded": false
        }),
        "name": "",
        "recentScheduledExecutionRecords": (
            json!({
                "errorStatus": json!({
                    "code": 0,
                    "details": (json!({})),
                    "message": ""
                }),
                "executionTime": "",
                "workflowInvocation": ""
            })
        ),
        "releaseConfig": "",
        "timeZone": ""
    });

    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}}/v1beta1/:parent/workflowConfigs \
  --header 'content-type: application/json' \
  --data '{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}'

echo '{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:parent/workflowConfigs \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "cronSchedule": "",\n  "invocationConfig": {\n    "fullyRefreshIncrementalTablesEnabled": false,\n    "includedTags": [],\n    "includedTargets": [\n      {\n        "database": "",\n        "name": "",\n        "schema": ""\n      }\n    ],\n    "transitiveDependenciesIncluded": false,\n    "transitiveDependentsIncluded": false\n  },\n  "name": "",\n  "recentScheduledExecutionRecords": [\n    {\n      "errorStatus": {\n        "code": 0,\n        "details": [\n          {}\n        ],\n        "message": ""\n      },\n      "executionTime": "",\n      "workflowInvocation": ""\n    }\n  ],\n  "releaseConfig": "",\n  "timeZone": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/workflowConfigs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "cronSchedule": "",
  "invocationConfig": [
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      [
        "database": "",
        "name": "",
        "schema": ""
      ]
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  ],
  "name": "",
  "recentScheduledExecutionRecords": [
    [
      "errorStatus": [
        "code": 0,
        "details": [[]],
        "message": ""
      ],
      "executionTime": "",
      "workflowInvocation": ""
    ]
  ],
  "releaseConfig": "",
  "timeZone": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:parent/workflowConfigs")! 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 dataform.projects.locations.repositories.workflowConfigs.list

{{baseUrl}}/v1beta1/:parent/workflowConfigs

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/workflowConfigs");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:parent/workflowConfigs")

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/workflowConfigs"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/workflowConfigs"

	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/v1beta1/:parent/workflowConfigs HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta1/:parent/workflowConfigs'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/workflowConfigs")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:parent/workflowConfigs');

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}}/v1beta1/:parent/workflowConfigs'
};

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

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

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

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

 "{{baseUrl}}/v1beta1/:parent/workflowConfigs",
  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}}/v1beta1/:parent/workflowConfigs');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/workflowConfigs');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:parent/workflowConfigs' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/workflowConfigs' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:parent/workflowConfigs")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/workflowConfigs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/workflowConfigs"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:parent/workflowConfigs")

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/v1beta1/:parent/workflowConfigs') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:parent/workflowConfigs

http GET {{baseUrl}}/v1beta1/:parent/workflowConfigs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/workflowConfigs

import Foundation

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

PATCH dataform.projects.locations.repositories.workflowConfigs.patch

{{baseUrl}}/v1beta1/:name

QUERY PARAMS

name

BODY json

{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1beta1/:name" {:content-type :json
                                                           :form-params {:cronSchedule ""
                                                                         :invocationConfig {:fullyRefreshIncrementalTablesEnabled false
                                                                                            :includedTags []
                                                                                            :includedTargets [{:database ""
                                                                                                               :name ""
                                                                                                               :schema ""}]
                                                                                            :transitiveDependenciesIncluded false
                                                                                            :transitiveDependentsIncluded false}
                                                                         :name ""
                                                                         :recentScheduledExecutionRecords [{:errorStatus {:code 0
                                                                                                                          :details [{}]
                                                                                                                          :message ""}
                                                                                                            :executionTime ""
                                                                                                            :workflowInvocation ""}]
                                                                         :releaseConfig ""
                                                                         :timeZone ""}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/v1beta1/:name"),
    Content = new StringContent("{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\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}}/v1beta1/:name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:name"

	payload := strings.NewReader("{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/v1beta1/:name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 615

{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1beta1/:name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:name"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\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  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1beta1/:name")
  .header("content-type", "application/json")
  .body("{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cronSchedule: '',
  invocationConfig: {
    fullyRefreshIncrementalTablesEnabled: false,
    includedTags: [],
    includedTargets: [
      {
        database: '',
        name: '',
        schema: ''
      }
    ],
    transitiveDependenciesIncluded: false,
    transitiveDependentsIncluded: false
  },
  name: '',
  recentScheduledExecutionRecords: [
    {
      errorStatus: {
        code: 0,
        details: [
          {}
        ],
        message: ''
      },
      executionTime: '',
      workflowInvocation: ''
    }
  ],
  releaseConfig: '',
  timeZone: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v1beta1/:name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta1/:name',
  headers: {'content-type': 'application/json'},
  data: {
    cronSchedule: '',
    invocationConfig: {
      fullyRefreshIncrementalTablesEnabled: false,
      includedTags: [],
      includedTargets: [{database: '', name: '', schema: ''}],
      transitiveDependenciesIncluded: false,
      transitiveDependentsIncluded: false
    },
    name: '',
    recentScheduledExecutionRecords: [
      {
        errorStatus: {code: 0, details: [{}], message: ''},
        executionTime: '',
        workflowInvocation: ''
      }
    ],
    releaseConfig: '',
    timeZone: ''
  }
};

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

const url = '{{baseUrl}}/v1beta1/:name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"cronSchedule":"","invocationConfig":{"fullyRefreshIncrementalTablesEnabled":false,"includedTags":[],"includedTargets":[{"database":"","name":"","schema":""}],"transitiveDependenciesIncluded":false,"transitiveDependentsIncluded":false},"name":"","recentScheduledExecutionRecords":[{"errorStatus":{"code":0,"details":[{}],"message":""},"executionTime":"","workflowInvocation":""}],"releaseConfig":"","timeZone":""}'
};

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}}/v1beta1/:name',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cronSchedule": "",\n  "invocationConfig": {\n    "fullyRefreshIncrementalTablesEnabled": false,\n    "includedTags": [],\n    "includedTargets": [\n      {\n        "database": "",\n        "name": "",\n        "schema": ""\n      }\n    ],\n    "transitiveDependenciesIncluded": false,\n    "transitiveDependentsIncluded": false\n  },\n  "name": "",\n  "recentScheduledExecutionRecords": [\n    {\n      "errorStatus": {\n        "code": 0,\n        "details": [\n          {}\n        ],\n        "message": ""\n      },\n      "executionTime": "",\n      "workflowInvocation": ""\n    }\n  ],\n  "releaseConfig": "",\n  "timeZone": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta1/:name',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  cronSchedule: '',
  invocationConfig: {
    fullyRefreshIncrementalTablesEnabled: false,
    includedTags: [],
    includedTargets: [{database: '', name: '', schema: ''}],
    transitiveDependenciesIncluded: false,
    transitiveDependentsIncluded: false
  },
  name: '',
  recentScheduledExecutionRecords: [
    {
      errorStatus: {code: 0, details: [{}], message: ''},
      executionTime: '',
      workflowInvocation: ''
    }
  ],
  releaseConfig: '',
  timeZone: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta1/:name',
  headers: {'content-type': 'application/json'},
  body: {
    cronSchedule: '',
    invocationConfig: {
      fullyRefreshIncrementalTablesEnabled: false,
      includedTags: [],
      includedTargets: [{database: '', name: '', schema: ''}],
      transitiveDependenciesIncluded: false,
      transitiveDependentsIncluded: false
    },
    name: '',
    recentScheduledExecutionRecords: [
      {
        errorStatus: {code: 0, details: [{}], message: ''},
        executionTime: '',
        workflowInvocation: ''
      }
    ],
    releaseConfig: '',
    timeZone: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/v1beta1/:name');

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

req.type('json');
req.send({
  cronSchedule: '',
  invocationConfig: {
    fullyRefreshIncrementalTablesEnabled: false,
    includedTags: [],
    includedTargets: [
      {
        database: '',
        name: '',
        schema: ''
      }
    ],
    transitiveDependenciesIncluded: false,
    transitiveDependentsIncluded: false
  },
  name: '',
  recentScheduledExecutionRecords: [
    {
      errorStatus: {
        code: 0,
        details: [
          {}
        ],
        message: ''
      },
      executionTime: '',
      workflowInvocation: ''
    }
  ],
  releaseConfig: '',
  timeZone: ''
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta1/:name',
  headers: {'content-type': 'application/json'},
  data: {
    cronSchedule: '',
    invocationConfig: {
      fullyRefreshIncrementalTablesEnabled: false,
      includedTags: [],
      includedTargets: [{database: '', name: '', schema: ''}],
      transitiveDependenciesIncluded: false,
      transitiveDependentsIncluded: false
    },
    name: '',
    recentScheduledExecutionRecords: [
      {
        errorStatus: {code: 0, details: [{}], message: ''},
        executionTime: '',
        workflowInvocation: ''
      }
    ],
    releaseConfig: '',
    timeZone: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta1/:name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"cronSchedule":"","invocationConfig":{"fullyRefreshIncrementalTablesEnabled":false,"includedTags":[],"includedTargets":[{"database":"","name":"","schema":""}],"transitiveDependenciesIncluded":false,"transitiveDependentsIncluded":false},"name":"","recentScheduledExecutionRecords":[{"errorStatus":{"code":0,"details":[{}],"message":""},"executionTime":"","workflowInvocation":""}],"releaseConfig":"","timeZone":""}'
};

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 = @{ @"cronSchedule": @"",
                              @"invocationConfig": @{ @"fullyRefreshIncrementalTablesEnabled": @NO, @"includedTags": @[  ], @"includedTargets": @[ @{ @"database": @"", @"name": @"", @"schema": @"" } ], @"transitiveDependenciesIncluded": @NO, @"transitiveDependentsIncluded": @NO },
                              @"name": @"",
                              @"recentScheduledExecutionRecords": @[ @{ @"errorStatus": @{ @"code": @0, @"details": @[ @{  } ], @"message": @"" }, @"executionTime": @"", @"workflowInvocation": @"" } ],
                              @"releaseConfig": @"",
                              @"timeZone": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/v1beta1/:name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta1/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'cronSchedule' => '',
    'invocationConfig' => [
        'fullyRefreshIncrementalTablesEnabled' => null,
        'includedTags' => [
                
        ],
        'includedTargets' => [
                [
                                'database' => '',
                                'name' => '',
                                'schema' => ''
                ]
        ],
        'transitiveDependenciesIncluded' => null,
        'transitiveDependentsIncluded' => null
    ],
    'name' => '',
    'recentScheduledExecutionRecords' => [
        [
                'errorStatus' => [
                                'code' => 0,
                                'details' => [
                                                                [
                                                                                                                                
                                                                ]
                                ],
                                'message' => ''
                ],
                'executionTime' => '',
                'workflowInvocation' => ''
        ]
    ],
    'releaseConfig' => '',
    'timeZone' => ''
  ]),
  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('PATCH', '{{baseUrl}}/v1beta1/:name', [
  'body' => '{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:name');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cronSchedule' => '',
  'invocationConfig' => [
    'fullyRefreshIncrementalTablesEnabled' => null,
    'includedTags' => [
        
    ],
    'includedTargets' => [
        [
                'database' => '',
                'name' => '',
                'schema' => ''
        ]
    ],
    'transitiveDependenciesIncluded' => null,
    'transitiveDependentsIncluded' => null
  ],
  'name' => '',
  'recentScheduledExecutionRecords' => [
    [
        'errorStatus' => [
                'code' => 0,
                'details' => [
                                [
                                                                
                                ]
                ],
                'message' => ''
        ],
        'executionTime' => '',
        'workflowInvocation' => ''
    ]
  ],
  'releaseConfig' => '',
  'timeZone' => ''
]));

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

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

append(json_encode([
  'cronSchedule' => '',
  'invocationConfig' => [
    'fullyRefreshIncrementalTablesEnabled' => null,
    'includedTags' => [
        
    ],
    'includedTargets' => [
        [
                'database' => '',
                'name' => '',
                'schema' => ''
        ]
    ],
    'transitiveDependenciesIncluded' => null,
    'transitiveDependentsIncluded' => null
  ],
  'name' => '',
  'recentScheduledExecutionRecords' => [
    [
        'errorStatus' => [
                'code' => 0,
                'details' => [
                                [
                                                                
                                ]
                ],
                'message' => ''
        ],
        'executionTime' => '',
        'workflowInvocation' => ''
    ]
  ],
  'releaseConfig' => '',
  'timeZone' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:name');
$request->setRequestMethod('PATCH');
$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}}/v1beta1/:name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}'

import http.client

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

payload = "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/v1beta1/:name", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:name"

payload = {
    "cronSchedule": "",
    "invocationConfig": {
        "fullyRefreshIncrementalTablesEnabled": False,
        "includedTags": [],
        "includedTargets": [
            {
                "database": "",
                "name": "",
                "schema": ""
            }
        ],
        "transitiveDependenciesIncluded": False,
        "transitiveDependentsIncluded": False
    },
    "name": "",
    "recentScheduledExecutionRecords": [
        {
            "errorStatus": {
                "code": 0,
                "details": [{}],
                "message": ""
            },
            "executionTime": "",
            "workflowInvocation": ""
        }
    ],
    "releaseConfig": "",
    "timeZone": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name"

payload <- "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:name")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\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.patch('/baseUrl/v1beta1/:name') do |req|
  req.body = "{\n  \"cronSchedule\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"name\": \"\",\n  \"recentScheduledExecutionRecords\": [\n    {\n      \"errorStatus\": {\n        \"code\": 0,\n        \"details\": [\n          {}\n        ],\n        \"message\": \"\"\n      },\n      \"executionTime\": \"\",\n      \"workflowInvocation\": \"\"\n    }\n  ],\n  \"releaseConfig\": \"\",\n  \"timeZone\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({
        "cronSchedule": "",
        "invocationConfig": json!({
            "fullyRefreshIncrementalTablesEnabled": false,
            "includedTags": (),
            "includedTargets": (
                json!({
                    "database": "",
                    "name": "",
                    "schema": ""
                })
            ),
            "transitiveDependenciesIncluded": false,
            "transitiveDependentsIncluded": false
        }),
        "name": "",
        "recentScheduledExecutionRecords": (
            json!({
                "errorStatus": json!({
                    "code": 0,
                    "details": (json!({})),
                    "message": ""
                }),
                "executionTime": "",
                "workflowInvocation": ""
            })
        ),
        "releaseConfig": "",
        "timeZone": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/v1beta1/:name \
  --header 'content-type: application/json' \
  --data '{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}'

echo '{
  "cronSchedule": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "name": "",
  "recentScheduledExecutionRecords": [
    {
      "errorStatus": {
        "code": 0,
        "details": [
          {}
        ],
        "message": ""
      },
      "executionTime": "",
      "workflowInvocation": ""
    }
  ],
  "releaseConfig": "",
  "timeZone": ""
}' |  \
  http PATCH {{baseUrl}}/v1beta1/:name \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "cronSchedule": "",\n  "invocationConfig": {\n    "fullyRefreshIncrementalTablesEnabled": false,\n    "includedTags": [],\n    "includedTargets": [\n      {\n        "database": "",\n        "name": "",\n        "schema": ""\n      }\n    ],\n    "transitiveDependenciesIncluded": false,\n    "transitiveDependentsIncluded": false\n  },\n  "name": "",\n  "recentScheduledExecutionRecords": [\n    {\n      "errorStatus": {\n        "code": 0,\n        "details": [\n          {}\n        ],\n        "message": ""\n      },\n      "executionTime": "",\n      "workflowInvocation": ""\n    }\n  ],\n  "releaseConfig": "",\n  "timeZone": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "cronSchedule": "",
  "invocationConfig": [
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      [
        "database": "",
        "name": "",
        "schema": ""
      ]
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  ],
  "name": "",
  "recentScheduledExecutionRecords": [
    [
      "errorStatus": [
        "code": 0,
        "details": [[]],
        "message": ""
      ],
      "executionTime": "",
      "workflowInvocation": ""
    ]
  ],
  "releaseConfig": "",
  "timeZone": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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 dataform.projects.locations.repositories.workflowInvocations.cancel

{{baseUrl}}/v1beta1/:name:cancel

QUERY PARAMS

name

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name:cancel");

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, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:name:cancel" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/v1beta1/:name:cancel"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/v1beta1/:name:cancel"),
    Content = new StringContent("{}")
    {
        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}}/v1beta1/:name:cancel");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:name:cancel"

	payload := strings.NewReader("{}")

	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/v1beta1/:name:cancel HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:name:cancel")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:name:cancel")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:name:cancel');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:name:cancel',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/v1beta1/:name:cancel';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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}}/v1beta1/:name:cancel',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:cancel")
  .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/v1beta1/:name:cancel',
  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({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:name:cancel',
  headers: {'content-type': 'application/json'},
  body: {},
  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}}/v1beta1/:name:cancel');

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

req.type('json');
req.send({});

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}}/v1beta1/:name:cancel',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

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

const url = '{{baseUrl}}/v1beta1/:name:cancel';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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 = @{  };

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

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

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

 "{{baseUrl}}/v1beta1/:name:cancel",
  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([
    
  ]),
  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}}/v1beta1/:name:cancel', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:name:cancel');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:name:cancel');
$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}}/v1beta1/:name:cancel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name:cancel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("POST", "/baseUrl/v1beta1/:name:cancel", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:name:cancel"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name:cancel"

payload <- "{}"

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}}/v1beta1/:name:cancel")

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 = "{}"

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/v1beta1/:name:cancel') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = 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}}/v1beta1/:name:cancel \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/v1beta1/:name:cancel \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:name:cancel

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:name:cancel")! 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 dataform.projects.locations.repositories.workflowInvocations.create

{{baseUrl}}/v1beta1/:parent/workflowInvocations

QUERY PARAMS

parent

BODY json

{
  "compilationResult": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "invocationTiming": {
    "endTime": "",
    "startTime": ""
  },
  "name": "",
  "state": "",
  "workflowConfig": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/workflowInvocations");

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  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:parent/workflowInvocations" {:content-type :json
                                                                                :form-params {:compilationResult ""
                                                                                              :invocationConfig {:fullyRefreshIncrementalTablesEnabled false
                                                                                                                 :includedTags []
                                                                                                                 :includedTargets [{:database ""
                                                                                                                                    :name ""
                                                                                                                                    :schema ""}]
                                                                                                                 :transitiveDependenciesIncluded false
                                                                                                                 :transitiveDependentsIncluded false}
                                                                                              :invocationTiming {:endTime ""
                                                                                                                 :startTime ""}
                                                                                              :name ""
                                                                                              :state ""
                                                                                              :workflowConfig ""}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/workflowInvocations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\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}}/v1beta1/:parent/workflowInvocations"),
    Content = new StringContent("{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\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}}/v1beta1/:parent/workflowInvocations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/workflowInvocations"

	payload := strings.NewReader("{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\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/v1beta1/:parent/workflowInvocations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 454

{
  "compilationResult": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "invocationTiming": {
    "endTime": "",
    "startTime": ""
  },
  "name": "",
  "state": "",
  "workflowConfig": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:parent/workflowInvocations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:parent/workflowInvocations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\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  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/workflowInvocations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:parent/workflowInvocations")
  .header("content-type", "application/json")
  .body("{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  compilationResult: '',
  invocationConfig: {
    fullyRefreshIncrementalTablesEnabled: false,
    includedTags: [],
    includedTargets: [
      {
        database: '',
        name: '',
        schema: ''
      }
    ],
    transitiveDependenciesIncluded: false,
    transitiveDependentsIncluded: false
  },
  invocationTiming: {
    endTime: '',
    startTime: ''
  },
  name: '',
  state: '',
  workflowConfig: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:parent/workflowInvocations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/workflowInvocations',
  headers: {'content-type': 'application/json'},
  data: {
    compilationResult: '',
    invocationConfig: {
      fullyRefreshIncrementalTablesEnabled: false,
      includedTags: [],
      includedTargets: [{database: '', name: '', schema: ''}],
      transitiveDependenciesIncluded: false,
      transitiveDependentsIncluded: false
    },
    invocationTiming: {endTime: '', startTime: ''},
    name: '',
    state: '',
    workflowConfig: ''
  }
};

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

const url = '{{baseUrl}}/v1beta1/:parent/workflowInvocations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"compilationResult":"","invocationConfig":{"fullyRefreshIncrementalTablesEnabled":false,"includedTags":[],"includedTargets":[{"database":"","name":"","schema":""}],"transitiveDependenciesIncluded":false,"transitiveDependentsIncluded":false},"invocationTiming":{"endTime":"","startTime":""},"name":"","state":"","workflowConfig":""}'
};

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}}/v1beta1/:parent/workflowInvocations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "compilationResult": "",\n  "invocationConfig": {\n    "fullyRefreshIncrementalTablesEnabled": false,\n    "includedTags": [],\n    "includedTargets": [\n      {\n        "database": "",\n        "name": "",\n        "schema": ""\n      }\n    ],\n    "transitiveDependenciesIncluded": false,\n    "transitiveDependentsIncluded": false\n  },\n  "invocationTiming": {\n    "endTime": "",\n    "startTime": ""\n  },\n  "name": "",\n  "state": "",\n  "workflowConfig": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/workflowInvocations")
  .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/v1beta1/:parent/workflowInvocations',
  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({
  compilationResult: '',
  invocationConfig: {
    fullyRefreshIncrementalTablesEnabled: false,
    includedTags: [],
    includedTargets: [{database: '', name: '', schema: ''}],
    transitiveDependenciesIncluded: false,
    transitiveDependentsIncluded: false
  },
  invocationTiming: {endTime: '', startTime: ''},
  name: '',
  state: '',
  workflowConfig: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/workflowInvocations',
  headers: {'content-type': 'application/json'},
  body: {
    compilationResult: '',
    invocationConfig: {
      fullyRefreshIncrementalTablesEnabled: false,
      includedTags: [],
      includedTargets: [{database: '', name: '', schema: ''}],
      transitiveDependenciesIncluded: false,
      transitiveDependentsIncluded: false
    },
    invocationTiming: {endTime: '', startTime: ''},
    name: '',
    state: '',
    workflowConfig: ''
  },
  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}}/v1beta1/:parent/workflowInvocations');

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

req.type('json');
req.send({
  compilationResult: '',
  invocationConfig: {
    fullyRefreshIncrementalTablesEnabled: false,
    includedTags: [],
    includedTargets: [
      {
        database: '',
        name: '',
        schema: ''
      }
    ],
    transitiveDependenciesIncluded: false,
    transitiveDependentsIncluded: false
  },
  invocationTiming: {
    endTime: '',
    startTime: ''
  },
  name: '',
  state: '',
  workflowConfig: ''
});

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}}/v1beta1/:parent/workflowInvocations',
  headers: {'content-type': 'application/json'},
  data: {
    compilationResult: '',
    invocationConfig: {
      fullyRefreshIncrementalTablesEnabled: false,
      includedTags: [],
      includedTargets: [{database: '', name: '', schema: ''}],
      transitiveDependenciesIncluded: false,
      transitiveDependentsIncluded: false
    },
    invocationTiming: {endTime: '', startTime: ''},
    name: '',
    state: '',
    workflowConfig: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta1/:parent/workflowInvocations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"compilationResult":"","invocationConfig":{"fullyRefreshIncrementalTablesEnabled":false,"includedTags":[],"includedTargets":[{"database":"","name":"","schema":""}],"transitiveDependenciesIncluded":false,"transitiveDependentsIncluded":false},"invocationTiming":{"endTime":"","startTime":""},"name":"","state":"","workflowConfig":""}'
};

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 = @{ @"compilationResult": @"",
                              @"invocationConfig": @{ @"fullyRefreshIncrementalTablesEnabled": @NO, @"includedTags": @[  ], @"includedTargets": @[ @{ @"database": @"", @"name": @"", @"schema": @"" } ], @"transitiveDependenciesIncluded": @NO, @"transitiveDependentsIncluded": @NO },
                              @"invocationTiming": @{ @"endTime": @"", @"startTime": @"" },
                              @"name": @"",
                              @"state": @"",
                              @"workflowConfig": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:parent/workflowInvocations"]
                                                       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}}/v1beta1/:parent/workflowInvocations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta1/:parent/workflowInvocations",
  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([
    'compilationResult' => '',
    'invocationConfig' => [
        'fullyRefreshIncrementalTablesEnabled' => null,
        'includedTags' => [
                
        ],
        'includedTargets' => [
                [
                                'database' => '',
                                'name' => '',
                                'schema' => ''
                ]
        ],
        'transitiveDependenciesIncluded' => null,
        'transitiveDependentsIncluded' => null
    ],
    'invocationTiming' => [
        'endTime' => '',
        'startTime' => ''
    ],
    'name' => '',
    'state' => '',
    'workflowConfig' => ''
  ]),
  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}}/v1beta1/:parent/workflowInvocations', [
  'body' => '{
  "compilationResult": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "invocationTiming": {
    "endTime": "",
    "startTime": ""
  },
  "name": "",
  "state": "",
  "workflowConfig": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/workflowInvocations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'compilationResult' => '',
  'invocationConfig' => [
    'fullyRefreshIncrementalTablesEnabled' => null,
    'includedTags' => [
        
    ],
    'includedTargets' => [
        [
                'database' => '',
                'name' => '',
                'schema' => ''
        ]
    ],
    'transitiveDependenciesIncluded' => null,
    'transitiveDependentsIncluded' => null
  ],
  'invocationTiming' => [
    'endTime' => '',
    'startTime' => ''
  ],
  'name' => '',
  'state' => '',
  'workflowConfig' => ''
]));

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

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

append(json_encode([
  'compilationResult' => '',
  'invocationConfig' => [
    'fullyRefreshIncrementalTablesEnabled' => null,
    'includedTags' => [
        
    ],
    'includedTargets' => [
        [
                'database' => '',
                'name' => '',
                'schema' => ''
        ]
    ],
    'transitiveDependenciesIncluded' => null,
    'transitiveDependentsIncluded' => null
  ],
  'invocationTiming' => [
    'endTime' => '',
    'startTime' => ''
  ],
  'name' => '',
  'state' => '',
  'workflowConfig' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:parent/workflowInvocations');
$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}}/v1beta1/:parent/workflowInvocations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "compilationResult": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "invocationTiming": {
    "endTime": "",
    "startTime": ""
  },
  "name": "",
  "state": "",
  "workflowConfig": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/workflowInvocations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "compilationResult": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "invocationTiming": {
    "endTime": "",
    "startTime": ""
  },
  "name": "",
  "state": "",
  "workflowConfig": ""
}'

import http.client

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

payload = "{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta1/:parent/workflowInvocations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/workflowInvocations"

payload = {
    "compilationResult": "",
    "invocationConfig": {
        "fullyRefreshIncrementalTablesEnabled": False,
        "includedTags": [],
        "includedTargets": [
            {
                "database": "",
                "name": "",
                "schema": ""
            }
        ],
        "transitiveDependenciesIncluded": False,
        "transitiveDependentsIncluded": False
    },
    "invocationTiming": {
        "endTime": "",
        "startTime": ""
    },
    "name": "",
    "state": "",
    "workflowConfig": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/workflowInvocations"

payload <- "{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\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}}/v1beta1/:parent/workflowInvocations")

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  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\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/v1beta1/:parent/workflowInvocations') do |req|
  req.body = "{\n  \"compilationResult\": \"\",\n  \"invocationConfig\": {\n    \"fullyRefreshIncrementalTablesEnabled\": false,\n    \"includedTags\": [],\n    \"includedTargets\": [\n      {\n        \"database\": \"\",\n        \"name\": \"\",\n        \"schema\": \"\"\n      }\n    ],\n    \"transitiveDependenciesIncluded\": false,\n    \"transitiveDependentsIncluded\": false\n  },\n  \"invocationTiming\": {\n    \"endTime\": \"\",\n    \"startTime\": \"\"\n  },\n  \"name\": \"\",\n  \"state\": \"\",\n  \"workflowConfig\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "compilationResult": "",
        "invocationConfig": json!({
            "fullyRefreshIncrementalTablesEnabled": false,
            "includedTags": (),
            "includedTargets": (
                json!({
                    "database": "",
                    "name": "",
                    "schema": ""
                })
            ),
            "transitiveDependenciesIncluded": false,
            "transitiveDependentsIncluded": false
        }),
        "invocationTiming": json!({
            "endTime": "",
            "startTime": ""
        }),
        "name": "",
        "state": "",
        "workflowConfig": ""
    });

    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}}/v1beta1/:parent/workflowInvocations \
  --header 'content-type: application/json' \
  --data '{
  "compilationResult": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "invocationTiming": {
    "endTime": "",
    "startTime": ""
  },
  "name": "",
  "state": "",
  "workflowConfig": ""
}'

echo '{
  "compilationResult": "",
  "invocationConfig": {
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      {
        "database": "",
        "name": "",
        "schema": ""
      }
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  },
  "invocationTiming": {
    "endTime": "",
    "startTime": ""
  },
  "name": "",
  "state": "",
  "workflowConfig": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:parent/workflowInvocations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "compilationResult": "",\n  "invocationConfig": {\n    "fullyRefreshIncrementalTablesEnabled": false,\n    "includedTags": [],\n    "includedTargets": [\n      {\n        "database": "",\n        "name": "",\n        "schema": ""\n      }\n    ],\n    "transitiveDependenciesIncluded": false,\n    "transitiveDependentsIncluded": false\n  },\n  "invocationTiming": {\n    "endTime": "",\n    "startTime": ""\n  },\n  "name": "",\n  "state": "",\n  "workflowConfig": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/workflowInvocations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "compilationResult": "",
  "invocationConfig": [
    "fullyRefreshIncrementalTablesEnabled": false,
    "includedTags": [],
    "includedTargets": [
      [
        "database": "",
        "name": "",
        "schema": ""
      ]
    ],
    "transitiveDependenciesIncluded": false,
    "transitiveDependentsIncluded": false
  ],
  "invocationTiming": [
    "endTime": "",
    "startTime": ""
  ],
  "name": "",
  "state": "",
  "workflowConfig": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:parent/workflowInvocations")! 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 dataform.projects.locations.repositories.workflowInvocations.list

{{baseUrl}}/v1beta1/:parent/workflowInvocations

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/workflowInvocations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:parent/workflowInvocations")

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/workflowInvocations"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/workflowInvocations"

	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/v1beta1/:parent/workflowInvocations HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta1/:parent/workflowInvocations'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/workflowInvocations")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:parent/workflowInvocations');

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}}/v1beta1/:parent/workflowInvocations'
};

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

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

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

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

 "{{baseUrl}}/v1beta1/:parent/workflowInvocations",
  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}}/v1beta1/:parent/workflowInvocations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/workflowInvocations');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:parent/workflowInvocations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/workflowInvocations' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:parent/workflowInvocations")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/workflowInvocations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/workflowInvocations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:parent/workflowInvocations")

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/v1beta1/:parent/workflowInvocations') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:parent/workflowInvocations

http GET {{baseUrl}}/v1beta1/:parent/workflowInvocations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/workflowInvocations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:parent/workflowInvocations")! 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 dataform.projects.locations.repositories.workflowInvocations.query

{{baseUrl}}/v1beta1/:name:query

QUERY PARAMS

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name:query");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:name:query")

require "http/client"

url = "{{baseUrl}}/v1beta1/:name:query"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:name:query"

	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/v1beta1/:name:query HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta1/:name:query'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:query")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:name:query');

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}}/v1beta1/:name:query'};

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

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

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

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

 "{{baseUrl}}/v1beta1/:name:query",
  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}}/v1beta1/:name:query');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:name:query');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:name:query' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name:query' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:name:query")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:name:query"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name:query"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:name:query")

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/v1beta1/:name:query') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:name:query

http GET {{baseUrl}}/v1beta1/:name:query

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:name:query

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:name:query")! 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 dataform.projects.locations.repositories.workspaces.commit

{{baseUrl}}/v1beta1/:name:commit

QUERY PARAMS

name

BODY json

{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "commitMessage": "",
  "paths": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name:commit");

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  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:name:commit" {:content-type :json
                                                                 :form-params {:author {:emailAddress ""
                                                                                        :name ""}
                                                                               :commitMessage ""
                                                                               :paths []}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:name:commit"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\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}}/v1beta1/:name:commit"),
    Content = new StringContent("{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\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}}/v1beta1/:name:commit");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:name:commit"

	payload := strings.NewReader("{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\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/v1beta1/:name:commit HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 98

{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "commitMessage": "",
  "paths": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:name:commit")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:name:commit"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\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  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:commit")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:name:commit")
  .header("content-type", "application/json")
  .body("{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\n}")
  .asString();

const data = JSON.stringify({
  author: {
    emailAddress: '',
    name: ''
  },
  commitMessage: '',
  paths: []
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:name:commit');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:name:commit',
  headers: {'content-type': 'application/json'},
  data: {author: {emailAddress: '', name: ''}, commitMessage: '', paths: []}
};

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

const url = '{{baseUrl}}/v1beta1/:name:commit';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"emailAddress":"","name":""},"commitMessage":"","paths":[]}'
};

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}}/v1beta1/:name:commit',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "author": {\n    "emailAddress": "",\n    "name": ""\n  },\n  "commitMessage": "",\n  "paths": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:commit")
  .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/v1beta1/:name:commit',
  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({author: {emailAddress: '', name: ''}, commitMessage: '', paths: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:name:commit',
  headers: {'content-type': 'application/json'},
  body: {author: {emailAddress: '', name: ''}, commitMessage: '', paths: []},
  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}}/v1beta1/:name:commit');

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

req.type('json');
req.send({
  author: {
    emailAddress: '',
    name: ''
  },
  commitMessage: '',
  paths: []
});

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}}/v1beta1/:name:commit',
  headers: {'content-type': 'application/json'},
  data: {author: {emailAddress: '', name: ''}, commitMessage: '', paths: []}
};

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

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

const url = '{{baseUrl}}/v1beta1/:name:commit';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"emailAddress":"","name":""},"commitMessage":"","paths":[]}'
};

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 = @{ @"author": @{ @"emailAddress": @"", @"name": @"" },
                              @"commitMessage": @"",
                              @"paths": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:name:commit"]
                                                       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}}/v1beta1/:name:commit" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\n}" in

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

 "{{baseUrl}}/v1beta1/:name:commit",
  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([
    'author' => [
        'emailAddress' => '',
        'name' => ''
    ],
    'commitMessage' => '',
    'paths' => [
        
    ]
  ]),
  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}}/v1beta1/:name:commit', [
  'body' => '{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "commitMessage": "",
  "paths": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:name:commit');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'author' => [
    'emailAddress' => '',
    'name' => ''
  ],
  'commitMessage' => '',
  'paths' => [
    
  ]
]));

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

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

append(json_encode([
  'author' => [
    'emailAddress' => '',
    'name' => ''
  ],
  'commitMessage' => '',
  'paths' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:name:commit');
$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}}/v1beta1/:name:commit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "commitMessage": "",
  "paths": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name:commit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "commitMessage": "",
  "paths": []
}'

import http.client

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

payload = "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\n}"

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

conn.request("POST", "/baseUrl/v1beta1/:name:commit", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:name:commit"

payload = {
    "author": {
        "emailAddress": "",
        "name": ""
    },
    "commitMessage": "",
    "paths": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name:commit"

payload <- "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\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}}/v1beta1/:name:commit")

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  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\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/v1beta1/:name:commit') do |req|
  req.body = "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"commitMessage\": \"\",\n  \"paths\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "author": json!({
            "emailAddress": "",
            "name": ""
        }),
        "commitMessage": "",
        "paths": ()
    });

    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}}/v1beta1/:name:commit \
  --header 'content-type: application/json' \
  --data '{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "commitMessage": "",
  "paths": []
}'

echo '{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "commitMessage": "",
  "paths": []
}' |  \
  http POST {{baseUrl}}/v1beta1/:name:commit \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "author": {\n    "emailAddress": "",\n    "name": ""\n  },\n  "commitMessage": "",\n  "paths": []\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:name:commit

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "author": [
    "emailAddress": "",
    "name": ""
  ],
  "commitMessage": "",
  "paths": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:name:commit")! 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 dataform.projects.locations.repositories.workspaces.create

{{baseUrl}}/v1beta1/:parent/workspaces

QUERY PARAMS

parent

BODY json

{
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/workspaces");

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  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:parent/workspaces" {:content-type :json
                                                                       :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/workspaces"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/v1beta1/:parent/workspaces");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/workspaces"

	payload := strings.NewReader("{\n  \"name\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/v1beta1/:parent/workspaces HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:parent/workspaces")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:parent/workspaces"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/workspaces")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:parent/workspaces")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:parent/workspaces');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/workspaces',
  headers: {'content-type': 'application/json'},
  data: {name: ''}
};

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

const url = '{{baseUrl}}/v1beta1/:parent/workspaces';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1beta1/:parent/workspaces',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/workspaces")
  .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/v1beta1/:parent/workspaces',
  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({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/workspaces',
  headers: {'content-type': 'application/json'},
  body: {name: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1beta1/:parent/workspaces');

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

req.type('json');
req.send({
  name: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:parent/workspaces',
  headers: {'content-type': 'application/json'},
  data: {name: ''}
};

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

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

const url = '{{baseUrl}}/v1beta1/:parent/workspaces';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"" };

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

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

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

 "{{baseUrl}}/v1beta1/:parent/workspaces",
  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([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v1beta1/:parent/workspaces', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/workspaces');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:parent/workspaces');
$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}}/v1beta1/:parent/workspaces' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/workspaces' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

import http.client

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

payload = "{\n  \"name\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta1/:parent/workspaces", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/workspaces"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/workspaces"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:parent/workspaces")

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  \"name\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1beta1/:parent/workspaces') do |req|
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1beta1/:parent/workspaces \
  --header 'content-type: application/json' \
  --data '{
  "name": ""
}'

echo '{
  "name": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:parent/workspaces \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/workspaces

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:parent/workspaces")! 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 dataform.projects.locations.repositories.workspaces.delete

{{baseUrl}}/v1beta1/:name

QUERY PARAMS

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1beta1/:name")

require "http/client"

url = "{{baseUrl}}/v1beta1/:name"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:name"

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

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

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

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

}

DELETE /baseUrl/v1beta1/:name HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1beta1/:name")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/v1beta1/:name');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1beta1/:name'};

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

const url = '{{baseUrl}}/v1beta1/:name';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1beta1/:name',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v1beta1/:name'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1beta1/:name');

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

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

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

const options = {method: 'DELETE', url: '{{baseUrl}}/v1beta1/:name'};

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

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

const url = '{{baseUrl}}/v1beta1/:name';
const options = {method: 'DELETE'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1beta1/:name" in

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

 "{{baseUrl}}/v1beta1/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/v1beta1/:name');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:name' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1beta1/:name")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:name")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/v1beta1/:name') do |req|
end

puts response.status
puts response.body

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

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1beta1/:name

http DELETE {{baseUrl}}/v1beta1/:name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1beta1/:name

import Foundation

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

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

dataTask.resume()

GET dataform.projects.locations.repositories.workspaces.fetchFileDiff

{{baseUrl}}/v1beta1/:workspace:fetchFileDiff

QUERY PARAMS

workspace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:workspace:fetchFileDiff");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:workspace:fetchFileDiff")

require "http/client"

url = "{{baseUrl}}/v1beta1/:workspace:fetchFileDiff"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:workspace:fetchFileDiff"

	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/v1beta1/:workspace:fetchFileDiff HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta1/:workspace:fetchFileDiff'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:fetchFileDiff")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:workspace:fetchFileDiff');

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}}/v1beta1/:workspace:fetchFileDiff'
};

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

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

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

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

 "{{baseUrl}}/v1beta1/:workspace:fetchFileDiff",
  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}}/v1beta1/:workspace:fetchFileDiff');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:workspace:fetchFileDiff');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:workspace:fetchFileDiff' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:workspace:fetchFileDiff' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:workspace:fetchFileDiff")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:workspace:fetchFileDiff"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:workspace:fetchFileDiff"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:workspace:fetchFileDiff")

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/v1beta1/:workspace:fetchFileDiff') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:workspace:fetchFileDiff

http GET {{baseUrl}}/v1beta1/:workspace:fetchFileDiff

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:workspace:fetchFileDiff

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:workspace:fetchFileDiff")! 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 dataform.projects.locations.repositories.workspaces.fetchFileGitStatuses

{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses

QUERY PARAMS

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses")

require "http/client"

url = "{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses"

	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/v1beta1/:name:fetchFileGitStatuses HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses');

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}}/v1beta1/:name:fetchFileGitStatuses'
};

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

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

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

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

 "{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses",
  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}}/v1beta1/:name:fetchFileGitStatuses');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:name:fetchFileGitStatuses")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses")

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/v1beta1/:name:fetchFileGitStatuses') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:name:fetchFileGitStatuses

http GET {{baseUrl}}/v1beta1/:name:fetchFileGitStatuses

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:name:fetchFileGitStatuses

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:name:fetchFileGitStatuses")! 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 dataform.projects.locations.repositories.workspaces.fetchGitAheadBehind

{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind

QUERY PARAMS

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind")

require "http/client"

url = "{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind"

	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/v1beta1/:name:fetchGitAheadBehind HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind');

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}}/v1beta1/:name:fetchGitAheadBehind'
};

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

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

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

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

 "{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind",
  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}}/v1beta1/:name:fetchGitAheadBehind');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:name:fetchGitAheadBehind")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind")

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/v1beta1/:name:fetchGitAheadBehind') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:name:fetchGitAheadBehind

http GET {{baseUrl}}/v1beta1/:name:fetchGitAheadBehind

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:name:fetchGitAheadBehind

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:name:fetchGitAheadBehind")! 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 dataform.projects.locations.repositories.workspaces.get

{{baseUrl}}/v1beta1/:name

QUERY PARAMS

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:name")

require "http/client"

url = "{{baseUrl}}/v1beta1/:name"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:name"

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

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

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

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

}

GET /baseUrl/v1beta1/:name HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/v1beta1/:name');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta1/:name'};

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

const url = '{{baseUrl}}/v1beta1/:name';
const options = {method: 'GET'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1beta1/:name'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:name');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/v1beta1/:name'};

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

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

const url = '{{baseUrl}}/v1beta1/:name';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1beta1/:name" in

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

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

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v1beta1/:name');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:name' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:name")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:name")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v1beta1/:name') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:name

http GET {{baseUrl}}/v1beta1/:name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:name

import Foundation

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

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

dataTask.resume()

GET dataform.projects.locations.repositories.workspaces.getIamPolicy

{{baseUrl}}/v1beta1/:resource:getIamPolicy

QUERY PARAMS

resource

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:resource:getIamPolicy");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:resource:getIamPolicy")

require "http/client"

url = "{{baseUrl}}/v1beta1/:resource:getIamPolicy"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:resource:getIamPolicy"

	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/v1beta1/:resource:getIamPolicy HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta1/:resource:getIamPolicy'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:resource:getIamPolicy")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:resource:getIamPolicy');

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}}/v1beta1/:resource:getIamPolicy'
};

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

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

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

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

 "{{baseUrl}}/v1beta1/:resource:getIamPolicy",
  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}}/v1beta1/:resource:getIamPolicy');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:resource:getIamPolicy');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:resource:getIamPolicy' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:resource:getIamPolicy' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:resource:getIamPolicy")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:resource:getIamPolicy"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:resource:getIamPolicy"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:resource:getIamPolicy")

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/v1beta1/:resource:getIamPolicy') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:resource:getIamPolicy

http GET {{baseUrl}}/v1beta1/:resource:getIamPolicy

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:resource:getIamPolicy

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:resource:getIamPolicy")! 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 dataform.projects.locations.repositories.workspaces.installNpmPackages

{{baseUrl}}/v1beta1/:workspace:installNpmPackages

QUERY PARAMS

workspace

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:workspace:installNpmPackages");

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, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:workspace:installNpmPackages" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/v1beta1/:workspace:installNpmPackages"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/v1beta1/:workspace:installNpmPackages"),
    Content = new StringContent("{}")
    {
        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}}/v1beta1/:workspace:installNpmPackages");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:workspace:installNpmPackages"

	payload := strings.NewReader("{}")

	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/v1beta1/:workspace:installNpmPackages HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:workspace:installNpmPackages")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:workspace:installNpmPackages")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:workspace:installNpmPackages');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:installNpmPackages',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/v1beta1/:workspace:installNpmPackages';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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}}/v1beta1/:workspace:installNpmPackages',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:installNpmPackages")
  .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/v1beta1/:workspace:installNpmPackages',
  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({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:installNpmPackages',
  headers: {'content-type': 'application/json'},
  body: {},
  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}}/v1beta1/:workspace:installNpmPackages');

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

req.type('json');
req.send({});

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}}/v1beta1/:workspace:installNpmPackages',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

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

const url = '{{baseUrl}}/v1beta1/:workspace:installNpmPackages';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

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 = @{  };

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

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

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

 "{{baseUrl}}/v1beta1/:workspace:installNpmPackages",
  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([
    
  ]),
  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}}/v1beta1/:workspace:installNpmPackages', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:workspace:installNpmPackages');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:workspace:installNpmPackages');
$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}}/v1beta1/:workspace:installNpmPackages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:workspace:installNpmPackages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

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

conn.request("POST", "/baseUrl/v1beta1/:workspace:installNpmPackages", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:workspace:installNpmPackages"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:workspace:installNpmPackages"

payload <- "{}"

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}}/v1beta1/:workspace:installNpmPackages")

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 = "{}"

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/v1beta1/:workspace:installNpmPackages') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = 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}}/v1beta1/:workspace:installNpmPackages \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/v1beta1/:workspace:installNpmPackages \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:workspace:installNpmPackages

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:workspace:installNpmPackages")! 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 dataform.projects.locations.repositories.workspaces.list

{{baseUrl}}/v1beta1/:parent/workspaces

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:parent/workspaces");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta1/:parent/workspaces")

require "http/client"

url = "{{baseUrl}}/v1beta1/:parent/workspaces"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:parent/workspaces"

	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/v1beta1/:parent/workspaces HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta1/:parent/workspaces'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:parent/workspaces")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:parent/workspaces');

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}}/v1beta1/:parent/workspaces'};

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

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

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

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

 "{{baseUrl}}/v1beta1/:parent/workspaces",
  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}}/v1beta1/:parent/workspaces');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:parent/workspaces');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:parent/workspaces' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:parent/workspaces' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta1/:parent/workspaces")

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

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

import requests

url = "{{baseUrl}}/v1beta1/:parent/workspaces"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:parent/workspaces"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:parent/workspaces")

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/v1beta1/:parent/workspaces') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta1/:parent/workspaces

http GET {{baseUrl}}/v1beta1/:parent/workspaces

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:parent/workspaces

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:parent/workspaces")! 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 dataform.projects.locations.repositories.workspaces.makeDirectory

{{baseUrl}}/v1beta1/:workspace:makeDirectory

QUERY PARAMS

workspace

BODY json

{
  "path": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:workspace:makeDirectory");

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  \"path\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:workspace:makeDirectory" {:content-type :json
                                                                             :form-params {:path ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:workspace:makeDirectory"

	payload := strings.NewReader("{\n  \"path\": \"\"\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/v1beta1/:workspace:makeDirectory HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "path": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:workspace:makeDirectory")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"path\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:workspace:makeDirectory")
  .header("content-type", "application/json")
  .body("{\n  \"path\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  path: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:workspace:makeDirectory');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:makeDirectory',
  headers: {'content-type': 'application/json'},
  data: {path: ''}
};

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

const url = '{{baseUrl}}/v1beta1/:workspace:makeDirectory';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"path":""}'
};

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}}/v1beta1/:workspace:makeDirectory',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "path": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"path\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:makeDirectory")
  .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/v1beta1/:workspace:makeDirectory',
  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({path: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:makeDirectory',
  headers: {'content-type': 'application/json'},
  body: {path: ''},
  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}}/v1beta1/:workspace:makeDirectory');

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

req.type('json');
req.send({
  path: ''
});

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}}/v1beta1/:workspace:makeDirectory',
  headers: {'content-type': 'application/json'},
  data: {path: ''}
};

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

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

const url = '{{baseUrl}}/v1beta1/:workspace:makeDirectory';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"path":""}'
};

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 = @{ @"path": @"" };

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

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

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

 "{{baseUrl}}/v1beta1/:workspace:makeDirectory",
  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([
    'path' => ''
  ]),
  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}}/v1beta1/:workspace:makeDirectory', [
  'body' => '{
  "path": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:workspace:makeDirectory');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'path' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:workspace:makeDirectory');
$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}}/v1beta1/:workspace:makeDirectory' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "path": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:workspace:makeDirectory' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "path": ""
}'

import http.client

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

payload = "{\n  \"path\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta1/:workspace:makeDirectory", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:workspace:makeDirectory"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:workspace:makeDirectory"

payload <- "{\n  \"path\": \"\"\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}}/v1beta1/:workspace:makeDirectory")

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  \"path\": \"\"\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/v1beta1/:workspace:makeDirectory') do |req|
  req.body = "{\n  \"path\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

    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}}/v1beta1/:workspace:makeDirectory \
  --header 'content-type: application/json' \
  --data '{
  "path": ""
}'

echo '{
  "path": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:workspace:makeDirectory \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "path": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:workspace:makeDirectory

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:workspace:makeDirectory")! 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 dataform.projects.locations.repositories.workspaces.moveDirectory

{{baseUrl}}/v1beta1/:workspace:moveDirectory

QUERY PARAMS

workspace

BODY json

{
  "newPath": "",
  "path": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:workspace:moveDirectory");

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  \"newPath\": \"\",\n  \"path\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:workspace:moveDirectory" {:content-type :json
                                                                             :form-params {:newPath ""
                                                                                           :path ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:workspace:moveDirectory"

	payload := strings.NewReader("{\n  \"newPath\": \"\",\n  \"path\": \"\"\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/v1beta1/:workspace:moveDirectory HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 33

{
  "newPath": "",
  "path": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:workspace:moveDirectory")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"newPath\": \"\",\n  \"path\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:workspace:moveDirectory")
  .header("content-type", "application/json")
  .body("{\n  \"newPath\": \"\",\n  \"path\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  newPath: '',
  path: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:workspace:moveDirectory');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:moveDirectory',
  headers: {'content-type': 'application/json'},
  data: {newPath: '', path: ''}
};

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

const url = '{{baseUrl}}/v1beta1/:workspace:moveDirectory';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"newPath":"","path":""}'
};

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}}/v1beta1/:workspace:moveDirectory',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "newPath": "",\n  "path": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"newPath\": \"\",\n  \"path\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:moveDirectory")
  .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/v1beta1/:workspace:moveDirectory',
  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({newPath: '', path: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:moveDirectory',
  headers: {'content-type': 'application/json'},
  body: {newPath: '', path: ''},
  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}}/v1beta1/:workspace:moveDirectory');

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

req.type('json');
req.send({
  newPath: '',
  path: ''
});

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}}/v1beta1/:workspace:moveDirectory',
  headers: {'content-type': 'application/json'},
  data: {newPath: '', path: ''}
};

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

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

const url = '{{baseUrl}}/v1beta1/:workspace:moveDirectory';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"newPath":"","path":""}'
};

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 = @{ @"newPath": @"",
                              @"path": @"" };

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

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

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

 "{{baseUrl}}/v1beta1/:workspace:moveDirectory",
  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([
    'newPath' => '',
    'path' => ''
  ]),
  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}}/v1beta1/:workspace:moveDirectory', [
  'body' => '{
  "newPath": "",
  "path": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:workspace:moveDirectory');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'newPath' => '',
  'path' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:workspace:moveDirectory');
$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}}/v1beta1/:workspace:moveDirectory' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "newPath": "",
  "path": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:workspace:moveDirectory' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "newPath": "",
  "path": ""
}'

import http.client

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

payload = "{\n  \"newPath\": \"\",\n  \"path\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta1/:workspace:moveDirectory", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta1/:workspace:moveDirectory"

payload = {
    "newPath": "",
    "path": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:workspace:moveDirectory"

payload <- "{\n  \"newPath\": \"\",\n  \"path\": \"\"\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}}/v1beta1/:workspace:moveDirectory")

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  \"newPath\": \"\",\n  \"path\": \"\"\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/v1beta1/:workspace:moveDirectory') do |req|
  req.body = "{\n  \"newPath\": \"\",\n  \"path\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "newPath": "",
        "path": ""
    });

    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}}/v1beta1/:workspace:moveDirectory \
  --header 'content-type: application/json' \
  --data '{
  "newPath": "",
  "path": ""
}'

echo '{
  "newPath": "",
  "path": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:workspace:moveDirectory \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "newPath": "",\n  "path": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:workspace:moveDirectory

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:workspace:moveDirectory")! 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 dataform.projects.locations.repositories.workspaces.moveFile

{{baseUrl}}/v1beta1/:workspace:moveFile

QUERY PARAMS

workspace

BODY json

{
  "newPath": "",
  "path": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:workspace:moveFile");

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  \"newPath\": \"\",\n  \"path\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta1/:workspace:moveFile" {:content-type :json
                                                                        :form-params {:newPath ""
                                                                                      :path ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta1/:workspace:moveFile"

	payload := strings.NewReader("{\n  \"newPath\": \"\",\n  \"path\": \"\"\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/v1beta1/:workspace:moveFile HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 33

{
  "newPath": "",
  "path": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:workspace:moveFile")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"newPath\": \"\",\n  \"path\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:workspace:moveFile")
  .header("content-type", "application/json")
  .body("{\n  \"newPath\": \"\",\n  \"path\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  newPath: '',
  path: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta1/:workspace:moveFile');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:moveFile',
  headers: {'content-type': 'application/json'},
  data: {newPath: '', path: ''}
};

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

const url = '{{baseUrl}}/v1beta1/:workspace:moveFile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"newPath":"","path":""}'
};

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}}/v1beta1/:workspace:moveFile',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "newPath": "",\n  "path": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"newPath\": \"\",\n  \"path\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:moveFile")
  .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/v1beta1/:workspace:moveFile',
  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({newPath: '', path: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:moveFile',
  headers: {'content-type': 'application/json'},
  body: {newPath: '', path: ''},
  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}}/v1beta1/:workspace:moveFile');

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

req.type('json');
req.send({
  newPath: '',
  path: ''
});

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}}/v1beta1/:workspace:moveFile',
  headers: {'content-type': 'application/json'},
  data: {newPath: '', path: ''}
};

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

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

const url = '{{baseUrl}}/v1beta1/:workspace:moveFile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"newPath":"","path":""}'
};

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 = @{ @"newPath": @"",
                              @"path": @"" };

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

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

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

 "{{baseUrl}}/v1beta1/:workspace:moveFile",
  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([
    'newPath' => '',
    'path' => ''
  ]),
  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}}/v1beta1/:workspace:moveFile', [
  'body' => '{
  "newPath": "",
  "path": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:workspace:moveFile');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'newPath' => '',
  'path' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:workspace:moveFile');
$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}}/v1beta1/:workspace:moveFile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "newPath": "",
  "path": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:workspace:moveFile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "newPath": "",
  "path": ""
}'

import http.client

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

payload = "{\n  \"newPath\": \"\",\n  \"path\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1beta1/:workspace:moveFile", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta1/:workspace:moveFile"

payload = {
    "newPath": "",
    "path": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:workspace:moveFile"

payload <- "{\n  \"newPath\": \"\",\n  \"path\": \"\"\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}}/v1beta1/:workspace:moveFile")

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  \"newPath\": \"\",\n  \"path\": \"\"\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/v1beta1/:workspace:moveFile') do |req|
  req.body = "{\n  \"newPath\": \"\",\n  \"path\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta1/:workspace:moveFile";

    let payload = json!({
        "newPath": "",
        "path": ""
    });

    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}}/v1beta1/:workspace:moveFile \
  --header 'content-type: application/json' \
  --data '{
  "newPath": "",
  "path": ""
}'

echo '{
  "newPath": "",
  "path": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:workspace:moveFile \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "newPath": "",\n  "path": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:workspace:moveFile

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "newPath": "",
  "path": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:workspace:moveFile")! 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 dataform.projects.locations.repositories.workspaces.pull

{{baseUrl}}/v1beta1/:name:pull

QUERY PARAMS

name

BODY json

{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "remoteBranch": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name:pull");

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  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1beta1/:name:pull" {:content-type :json
                                                               :form-params {:author {:emailAddress ""
                                                                                      :name ""}
                                                                             :remoteBranch ""}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:name:pull"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\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}}/v1beta1/:name:pull"),
    Content = new StringContent("{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\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}}/v1beta1/:name:pull");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta1/:name:pull"

	payload := strings.NewReader("{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\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/v1beta1/:name:pull HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 82

{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "remoteBranch": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:name:pull")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:name:pull"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\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  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:pull")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:name:pull")
  .header("content-type", "application/json")
  .body("{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  author: {
    emailAddress: '',
    name: ''
  },
  remoteBranch: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1beta1/:name:pull');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:name:pull',
  headers: {'content-type': 'application/json'},
  data: {author: {emailAddress: '', name: ''}, remoteBranch: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta1/:name:pull';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"emailAddress":"","name":""},"remoteBranch":""}'
};

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}}/v1beta1/:name:pull',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "author": {\n    "emailAddress": "",\n    "name": ""\n  },\n  "remoteBranch": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:pull")
  .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/v1beta1/:name:pull',
  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({author: {emailAddress: '', name: ''}, remoteBranch: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:name:pull',
  headers: {'content-type': 'application/json'},
  body: {author: {emailAddress: '', name: ''}, remoteBranch: ''},
  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}}/v1beta1/:name:pull');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  author: {
    emailAddress: '',
    name: ''
  },
  remoteBranch: ''
});

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}}/v1beta1/:name:pull',
  headers: {'content-type': 'application/json'},
  data: {author: {emailAddress: '', name: ''}, remoteBranch: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta1/:name:pull';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"author":{"emailAddress":"","name":""},"remoteBranch":""}'
};

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 = @{ @"author": @{ @"emailAddress": @"", @"name": @"" },
                              @"remoteBranch": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:name:pull"]
                                                       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}}/v1beta1/:name:pull" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta1/:name:pull",
  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([
    'author' => [
        'emailAddress' => '',
        'name' => ''
    ],
    'remoteBranch' => ''
  ]),
  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}}/v1beta1/:name:pull', [
  'body' => '{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "remoteBranch": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:name:pull');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'author' => [
    'emailAddress' => '',
    'name' => ''
  ],
  'remoteBranch' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'author' => [
    'emailAddress' => '',
    'name' => ''
  ],
  'remoteBranch' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:name:pull');
$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}}/v1beta1/:name:pull' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "remoteBranch": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name:pull' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "remoteBranch": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1beta1/:name:pull", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta1/:name:pull"

payload = {
    "author": {
        "emailAddress": "",
        "name": ""
    },
    "remoteBranch": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name:pull"

payload <- "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\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}}/v1beta1/:name:pull")

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  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\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/v1beta1/:name:pull') do |req|
  req.body = "{\n  \"author\": {\n    \"emailAddress\": \"\",\n    \"name\": \"\"\n  },\n  \"remoteBranch\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta1/:name:pull";

    let payload = json!({
        "author": json!({
            "emailAddress": "",
            "name": ""
        }),
        "remoteBranch": ""
    });

    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}}/v1beta1/:name:pull \
  --header 'content-type: application/json' \
  --data '{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "remoteBranch": ""
}'

echo '{
  "author": {
    "emailAddress": "",
    "name": ""
  },
  "remoteBranch": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:name:pull \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "author": {\n    "emailAddress": "",\n    "name": ""\n  },\n  "remoteBranch": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:name:pull

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "author": [
    "emailAddress": "",
    "name": ""
  ],
  "remoteBranch": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:name:pull")! 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 dataform.projects.locations.repositories.workspaces.push

{{baseUrl}}/v1beta1/:name:push

QUERY PARAMS

name

BODY json

{
  "remoteBranch": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name:push");

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  \"remoteBranch\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1beta1/:name:push" {:content-type :json
                                                               :form-params {:remoteBranch ""}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:name:push"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"remoteBranch\": \"\"\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}}/v1beta1/:name:push"),
    Content = new StringContent("{\n  \"remoteBranch\": \"\"\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}}/v1beta1/:name:push");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"remoteBranch\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta1/:name:push"

	payload := strings.NewReader("{\n  \"remoteBranch\": \"\"\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/v1beta1/:name:push HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24

{
  "remoteBranch": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:name:push")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"remoteBranch\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:name:push"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"remoteBranch\": \"\"\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  \"remoteBranch\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:push")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:name:push")
  .header("content-type", "application/json")
  .body("{\n  \"remoteBranch\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  remoteBranch: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1beta1/:name:push');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:name:push',
  headers: {'content-type': 'application/json'},
  data: {remoteBranch: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta1/:name:push';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"remoteBranch":""}'
};

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}}/v1beta1/:name:push',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "remoteBranch": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"remoteBranch\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:push")
  .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/v1beta1/:name:push',
  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({remoteBranch: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:name:push',
  headers: {'content-type': 'application/json'},
  body: {remoteBranch: ''},
  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}}/v1beta1/:name:push');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  remoteBranch: ''
});

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}}/v1beta1/:name:push',
  headers: {'content-type': 'application/json'},
  data: {remoteBranch: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta1/:name:push';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"remoteBranch":""}'
};

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 = @{ @"remoteBranch": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:name:push"]
                                                       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}}/v1beta1/:name:push" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"remoteBranch\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta1/:name:push",
  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([
    'remoteBranch' => ''
  ]),
  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}}/v1beta1/:name:push', [
  'body' => '{
  "remoteBranch": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:name:push');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'remoteBranch' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'remoteBranch' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:name:push');
$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}}/v1beta1/:name:push' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "remoteBranch": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name:push' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "remoteBranch": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"remoteBranch\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1beta1/:name:push", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta1/:name:push"

payload = { "remoteBranch": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name:push"

payload <- "{\n  \"remoteBranch\": \"\"\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}}/v1beta1/:name:push")

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  \"remoteBranch\": \"\"\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/v1beta1/:name:push') do |req|
  req.body = "{\n  \"remoteBranch\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta1/:name:push";

    let payload = json!({"remoteBranch": ""});

    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}}/v1beta1/:name:push \
  --header 'content-type: application/json' \
  --data '{
  "remoteBranch": ""
}'

echo '{
  "remoteBranch": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:name:push \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "remoteBranch": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:name:push

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["remoteBranch": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:name:push")! 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 dataform.projects.locations.repositories.workspaces.queryDirectoryContents

{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents

QUERY PARAMS

workspace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents")

require "http/client"

url = "{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents"

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}}/v1beta1/:workspace:queryDirectoryContents"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents"

	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/v1beta1/:workspace:queryDirectoryContents HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents"))
    .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}}/v1beta1/:workspace:queryDirectoryContents")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents")
  .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}}/v1beta1/:workspace:queryDirectoryContents');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents';
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}}/v1beta1/:workspace:queryDirectoryContents',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta1/:workspace:queryDirectoryContents',
  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}}/v1beta1/:workspace:queryDirectoryContents'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents');

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}}/v1beta1/:workspace:queryDirectoryContents'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents';
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}}/v1beta1/:workspace:queryDirectoryContents"]
                                                       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}}/v1beta1/:workspace:queryDirectoryContents" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents",
  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}}/v1beta1/:workspace:queryDirectoryContents');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1beta1/:workspace:queryDirectoryContents")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents")

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/v1beta1/:workspace:queryDirectoryContents') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents";

    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}}/v1beta1/:workspace:queryDirectoryContents

http GET {{baseUrl}}/v1beta1/:workspace:queryDirectoryContents

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:workspace:queryDirectoryContents

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:workspace:queryDirectoryContents")! 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 dataform.projects.locations.repositories.workspaces.readFile

{{baseUrl}}/v1beta1/:workspace:readFile

QUERY PARAMS

workspace

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:workspace:readFile");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1beta1/:workspace:readFile")

require "http/client"

url = "{{baseUrl}}/v1beta1/:workspace:readFile"

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}}/v1beta1/:workspace:readFile"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta1/:workspace:readFile");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta1/:workspace:readFile"

	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/v1beta1/:workspace:readFile HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta1/:workspace:readFile")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:workspace:readFile"))
    .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}}/v1beta1/:workspace:readFile")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta1/:workspace:readFile")
  .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}}/v1beta1/:workspace:readFile');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta1/:workspace:readFile'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta1/:workspace:readFile';
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}}/v1beta1/:workspace:readFile',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:readFile")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta1/:workspace:readFile',
  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}}/v1beta1/:workspace:readFile'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta1/:workspace:readFile');

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}}/v1beta1/:workspace:readFile'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta1/:workspace:readFile';
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}}/v1beta1/:workspace:readFile"]
                                                       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}}/v1beta1/:workspace:readFile" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta1/:workspace:readFile",
  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}}/v1beta1/:workspace:readFile');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:workspace:readFile');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1beta1/:workspace:readFile');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta1/:workspace:readFile' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:workspace:readFile' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1beta1/:workspace:readFile")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta1/:workspace:readFile"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:workspace:readFile"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:workspace:readFile")

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/v1beta1/:workspace:readFile') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta1/:workspace:readFile";

    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}}/v1beta1/:workspace:readFile

http GET {{baseUrl}}/v1beta1/:workspace:readFile

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta1/:workspace:readFile

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:workspace:readFile")! 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 dataform.projects.locations.repositories.workspaces.removeDirectory

{{baseUrl}}/v1beta1/:workspace:removeDirectory

QUERY PARAMS

workspace

BODY json

{
  "path": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:workspace:removeDirectory");

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  \"path\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1beta1/:workspace:removeDirectory" {:content-type :json
                                                                               :form-params {:path ""}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:workspace:removeDirectory"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"path\": \"\"\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}}/v1beta1/:workspace:removeDirectory"),
    Content = new StringContent("{\n  \"path\": \"\"\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}}/v1beta1/:workspace:removeDirectory");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"path\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta1/:workspace:removeDirectory"

	payload := strings.NewReader("{\n  \"path\": \"\"\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/v1beta1/:workspace:removeDirectory HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "path": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:workspace:removeDirectory")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"path\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:workspace:removeDirectory"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"path\": \"\"\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  \"path\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:removeDirectory")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:workspace:removeDirectory")
  .header("content-type", "application/json")
  .body("{\n  \"path\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  path: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1beta1/:workspace:removeDirectory');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:removeDirectory',
  headers: {'content-type': 'application/json'},
  data: {path: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta1/:workspace:removeDirectory';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"path":""}'
};

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}}/v1beta1/:workspace:removeDirectory',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "path": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"path\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:removeDirectory")
  .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/v1beta1/:workspace:removeDirectory',
  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({path: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:removeDirectory',
  headers: {'content-type': 'application/json'},
  body: {path: ''},
  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}}/v1beta1/:workspace:removeDirectory');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  path: ''
});

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}}/v1beta1/:workspace:removeDirectory',
  headers: {'content-type': 'application/json'},
  data: {path: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta1/:workspace:removeDirectory';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"path":""}'
};

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 = @{ @"path": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:workspace:removeDirectory"]
                                                       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}}/v1beta1/:workspace:removeDirectory" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"path\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta1/:workspace:removeDirectory",
  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([
    'path' => ''
  ]),
  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}}/v1beta1/:workspace:removeDirectory', [
  'body' => '{
  "path": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:workspace:removeDirectory');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'path' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'path' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:workspace:removeDirectory');
$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}}/v1beta1/:workspace:removeDirectory' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "path": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:workspace:removeDirectory' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "path": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"path\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1beta1/:workspace:removeDirectory", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta1/:workspace:removeDirectory"

payload = { "path": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:workspace:removeDirectory"

payload <- "{\n  \"path\": \"\"\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}}/v1beta1/:workspace:removeDirectory")

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  \"path\": \"\"\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/v1beta1/:workspace:removeDirectory') do |req|
  req.body = "{\n  \"path\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta1/:workspace:removeDirectory";

    let payload = json!({"path": ""});

    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}}/v1beta1/:workspace:removeDirectory \
  --header 'content-type: application/json' \
  --data '{
  "path": ""
}'

echo '{
  "path": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:workspace:removeDirectory \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "path": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:workspace:removeDirectory

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["path": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:workspace:removeDirectory")! 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 dataform.projects.locations.repositories.workspaces.removeFile

{{baseUrl}}/v1beta1/:workspace:removeFile

QUERY PARAMS

workspace

BODY json

{
  "path": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:workspace:removeFile");

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  \"path\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1beta1/:workspace:removeFile" {:content-type :json
                                                                          :form-params {:path ""}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:workspace:removeFile"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"path\": \"\"\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}}/v1beta1/:workspace:removeFile"),
    Content = new StringContent("{\n  \"path\": \"\"\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}}/v1beta1/:workspace:removeFile");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"path\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta1/:workspace:removeFile"

	payload := strings.NewReader("{\n  \"path\": \"\"\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/v1beta1/:workspace:removeFile HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "path": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:workspace:removeFile")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"path\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:workspace:removeFile"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"path\": \"\"\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  \"path\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:removeFile")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:workspace:removeFile")
  .header("content-type", "application/json")
  .body("{\n  \"path\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  path: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1beta1/:workspace:removeFile');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:removeFile',
  headers: {'content-type': 'application/json'},
  data: {path: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta1/:workspace:removeFile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"path":""}'
};

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}}/v1beta1/:workspace:removeFile',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "path": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"path\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:removeFile")
  .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/v1beta1/:workspace:removeFile',
  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({path: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:removeFile',
  headers: {'content-type': 'application/json'},
  body: {path: ''},
  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}}/v1beta1/:workspace:removeFile');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  path: ''
});

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}}/v1beta1/:workspace:removeFile',
  headers: {'content-type': 'application/json'},
  data: {path: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta1/:workspace:removeFile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"path":""}'
};

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 = @{ @"path": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:workspace:removeFile"]
                                                       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}}/v1beta1/:workspace:removeFile" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"path\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta1/:workspace:removeFile",
  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([
    'path' => ''
  ]),
  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}}/v1beta1/:workspace:removeFile', [
  'body' => '{
  "path": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:workspace:removeFile');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'path' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'path' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:workspace:removeFile');
$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}}/v1beta1/:workspace:removeFile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "path": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:workspace:removeFile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "path": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"path\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1beta1/:workspace:removeFile", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta1/:workspace:removeFile"

payload = { "path": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:workspace:removeFile"

payload <- "{\n  \"path\": \"\"\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}}/v1beta1/:workspace:removeFile")

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  \"path\": \"\"\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/v1beta1/:workspace:removeFile') do |req|
  req.body = "{\n  \"path\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta1/:workspace:removeFile";

    let payload = json!({"path": ""});

    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}}/v1beta1/:workspace:removeFile \
  --header 'content-type: application/json' \
  --data '{
  "path": ""
}'

echo '{
  "path": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:workspace:removeFile \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "path": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:workspace:removeFile

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["path": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:workspace:removeFile")! 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 dataform.projects.locations.repositories.workspaces.reset

{{baseUrl}}/v1beta1/:name:reset

QUERY PARAMS

name

BODY json

{
  "clean": false,
  "paths": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:name:reset");

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  \"clean\": false,\n  \"paths\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1beta1/:name:reset" {:content-type :json
                                                                :form-params {:clean false
                                                                              :paths []}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:name:reset"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"clean\": false,\n  \"paths\": []\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}}/v1beta1/:name:reset"),
    Content = new StringContent("{\n  \"clean\": false,\n  \"paths\": []\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}}/v1beta1/:name:reset");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"clean\": false,\n  \"paths\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta1/:name:reset"

	payload := strings.NewReader("{\n  \"clean\": false,\n  \"paths\": []\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/v1beta1/:name:reset HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "clean": false,
  "paths": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:name:reset")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clean\": false,\n  \"paths\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:name:reset"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clean\": false,\n  \"paths\": []\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  \"clean\": false,\n  \"paths\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:reset")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:name:reset")
  .header("content-type", "application/json")
  .body("{\n  \"clean\": false,\n  \"paths\": []\n}")
  .asString();

const data = JSON.stringify({
  clean: false,
  paths: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1beta1/:name:reset');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:name:reset',
  headers: {'content-type': 'application/json'},
  data: {clean: false, paths: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta1/:name:reset';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"clean":false,"paths":[]}'
};

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}}/v1beta1/:name:reset',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clean": false,\n  "paths": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clean\": false,\n  \"paths\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:name:reset")
  .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/v1beta1/:name:reset',
  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({clean: false, paths: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:name:reset',
  headers: {'content-type': 'application/json'},
  body: {clean: false, paths: []},
  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}}/v1beta1/:name:reset');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  clean: false,
  paths: []
});

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}}/v1beta1/:name:reset',
  headers: {'content-type': 'application/json'},
  data: {clean: false, paths: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta1/:name:reset';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"clean":false,"paths":[]}'
};

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 = @{ @"clean": @NO,
                              @"paths": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:name:reset"]
                                                       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}}/v1beta1/:name:reset" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"clean\": false,\n  \"paths\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta1/:name:reset",
  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([
    'clean' => null,
    'paths' => [
        
    ]
  ]),
  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}}/v1beta1/:name:reset', [
  'body' => '{
  "clean": false,
  "paths": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:name:reset');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clean' => null,
  'paths' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'clean' => null,
  'paths' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:name:reset');
$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}}/v1beta1/:name:reset' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clean": false,
  "paths": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:name:reset' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clean": false,
  "paths": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"clean\": false,\n  \"paths\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1beta1/:name:reset", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta1/:name:reset"

payload = {
    "clean": False,
    "paths": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:name:reset"

payload <- "{\n  \"clean\": false,\n  \"paths\": []\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}}/v1beta1/:name:reset")

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  \"clean\": false,\n  \"paths\": []\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/v1beta1/:name:reset') do |req|
  req.body = "{\n  \"clean\": false,\n  \"paths\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta1/:name:reset";

    let payload = json!({
        "clean": false,
        "paths": ()
    });

    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}}/v1beta1/:name:reset \
  --header 'content-type: application/json' \
  --data '{
  "clean": false,
  "paths": []
}'

echo '{
  "clean": false,
  "paths": []
}' |  \
  http POST {{baseUrl}}/v1beta1/:name:reset \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "clean": false,\n  "paths": []\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:name:reset

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "clean": false,
  "paths": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:name:reset")! 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 dataform.projects.locations.repositories.workspaces.setIamPolicy

{{baseUrl}}/v1beta1/:resource:setIamPolicy

QUERY PARAMS

resource

BODY json

{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:resource:setIamPolicy");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1beta1/:resource:setIamPolicy" {:content-type :json
                                                                           :form-params {:policy {:bindings [{:condition {:description ""
                                                                                                                          :expression ""
                                                                                                                          :location ""
                                                                                                                          :title ""}
                                                                                                              :members []
                                                                                                              :role ""}]
                                                                                                  :etag ""
                                                                                                  :version 0}}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:resource:setIamPolicy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1beta1/:resource:setIamPolicy"),
    Content = new StringContent("{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta1/:resource:setIamPolicy");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta1/:resource:setIamPolicy"

	payload := strings.NewReader("{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1beta1/:resource:setIamPolicy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 276

{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:resource:setIamPolicy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:resource:setIamPolicy"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:resource:setIamPolicy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:resource:setIamPolicy")
  .header("content-type", "application/json")
  .body("{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}")
  .asString();

const data = JSON.stringify({
  policy: {
    bindings: [
      {
        condition: {
          description: '',
          expression: '',
          location: '',
          title: ''
        },
        members: [],
        role: ''
      }
    ],
    etag: '',
    version: 0
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1beta1/:resource:setIamPolicy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:resource:setIamPolicy',
  headers: {'content-type': 'application/json'},
  data: {
    policy: {
      bindings: [
        {
          condition: {description: '', expression: '', location: '', title: ''},
          members: [],
          role: ''
        }
      ],
      etag: '',
      version: 0
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta1/:resource:setIamPolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"policy":{"bindings":[{"condition":{"description":"","expression":"","location":"","title":""},"members":[],"role":""}],"etag":"","version":0}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1beta1/:resource:setIamPolicy',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "policy": {\n    "bindings": [\n      {\n        "condition": {\n          "description": "",\n          "expression": "",\n          "location": "",\n          "title": ""\n        },\n        "members": [],\n        "role": ""\n      }\n    ],\n    "etag": "",\n    "version": 0\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:resource:setIamPolicy")
  .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/v1beta1/:resource:setIamPolicy',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  policy: {
    bindings: [
      {
        condition: {description: '', expression: '', location: '', title: ''},
        members: [],
        role: ''
      }
    ],
    etag: '',
    version: 0
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:resource:setIamPolicy',
  headers: {'content-type': 'application/json'},
  body: {
    policy: {
      bindings: [
        {
          condition: {description: '', expression: '', location: '', title: ''},
          members: [],
          role: ''
        }
      ],
      etag: '',
      version: 0
    }
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1beta1/:resource:setIamPolicy');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  policy: {
    bindings: [
      {
        condition: {
          description: '',
          expression: '',
          location: '',
          title: ''
        },
        members: [],
        role: ''
      }
    ],
    etag: '',
    version: 0
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:resource:setIamPolicy',
  headers: {'content-type': 'application/json'},
  data: {
    policy: {
      bindings: [
        {
          condition: {description: '', expression: '', location: '', title: ''},
          members: [],
          role: ''
        }
      ],
      etag: '',
      version: 0
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta1/:resource:setIamPolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"policy":{"bindings":[{"condition":{"description":"","expression":"","location":"","title":""},"members":[],"role":""}],"etag":"","version":0}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"policy": @{ @"bindings": @[ @{ @"condition": @{ @"description": @"", @"expression": @"", @"location": @"", @"title": @"" }, @"members": @[  ], @"role": @"" } ], @"etag": @"", @"version": @0 } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:resource:setIamPolicy"]
                                                       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}}/v1beta1/:resource:setIamPolicy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta1/:resource:setIamPolicy",
  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([
    'policy' => [
        'bindings' => [
                [
                                'condition' => [
                                                                'description' => '',
                                                                'expression' => '',
                                                                'location' => '',
                                                                'title' => ''
                                ],
                                'members' => [
                                                                
                                ],
                                'role' => ''
                ]
        ],
        'etag' => '',
        'version' => 0
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1beta1/:resource:setIamPolicy', [
  'body' => '{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:resource:setIamPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'policy' => [
    'bindings' => [
        [
                'condition' => [
                                'description' => '',
                                'expression' => '',
                                'location' => '',
                                'title' => ''
                ],
                'members' => [
                                
                ],
                'role' => ''
        ]
    ],
    'etag' => '',
    'version' => 0
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'policy' => [
    'bindings' => [
        [
                'condition' => [
                                'description' => '',
                                'expression' => '',
                                'location' => '',
                                'title' => ''
                ],
                'members' => [
                                
                ],
                'role' => ''
        ]
    ],
    'etag' => '',
    'version' => 0
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:resource:setIamPolicy');
$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}}/v1beta1/:resource:setIamPolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:resource:setIamPolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1beta1/:resource:setIamPolicy", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta1/:resource:setIamPolicy"

payload = { "policy": {
        "bindings": [
            {
                "condition": {
                    "description": "",
                    "expression": "",
                    "location": "",
                    "title": ""
                },
                "members": [],
                "role": ""
            }
        ],
        "etag": "",
        "version": 0
    } }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:resource:setIamPolicy"

payload <- "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta1/:resource:setIamPolicy")

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  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1beta1/:resource:setIamPolicy') do |req|
  req.body = "{\n  \"policy\": {\n    \"bindings\": [\n      {\n        \"condition\": {\n          \"description\": \"\",\n          \"expression\": \"\",\n          \"location\": \"\",\n          \"title\": \"\"\n        },\n        \"members\": [],\n        \"role\": \"\"\n      }\n    ],\n    \"etag\": \"\",\n    \"version\": 0\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta1/:resource:setIamPolicy";

    let payload = json!({"policy": json!({
            "bindings": (
                json!({
                    "condition": json!({
                        "description": "",
                        "expression": "",
                        "location": "",
                        "title": ""
                    }),
                    "members": (),
                    "role": ""
                })
            ),
            "etag": "",
            "version": 0
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1beta1/:resource:setIamPolicy \
  --header 'content-type: application/json' \
  --data '{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}'

echo '{
  "policy": {
    "bindings": [
      {
        "condition": {
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        },
        "members": [],
        "role": ""
      }
    ],
    "etag": "",
    "version": 0
  }
}' |  \
  http POST {{baseUrl}}/v1beta1/:resource:setIamPolicy \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "policy": {\n    "bindings": [\n      {\n        "condition": {\n          "description": "",\n          "expression": "",\n          "location": "",\n          "title": ""\n        },\n        "members": [],\n        "role": ""\n      }\n    ],\n    "etag": "",\n    "version": 0\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:resource:setIamPolicy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["policy": [
    "bindings": [
      [
        "condition": [
          "description": "",
          "expression": "",
          "location": "",
          "title": ""
        ],
        "members": [],
        "role": ""
      ]
    ],
    "etag": "",
    "version": 0
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:resource:setIamPolicy")! 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 dataform.projects.locations.repositories.workspaces.testIamPermissions

{{baseUrl}}/v1beta1/:resource:testIamPermissions

QUERY PARAMS

resource

BODY json

{
  "permissions": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:resource:testIamPermissions");

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  \"permissions\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1beta1/:resource:testIamPermissions" {:content-type :json
                                                                                 :form-params {:permissions []}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:resource:testIamPermissions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"permissions\": []\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}}/v1beta1/:resource:testIamPermissions"),
    Content = new StringContent("{\n  \"permissions\": []\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}}/v1beta1/:resource:testIamPermissions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"permissions\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta1/:resource:testIamPermissions"

	payload := strings.NewReader("{\n  \"permissions\": []\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/v1beta1/:resource:testIamPermissions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "permissions": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:resource:testIamPermissions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"permissions\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:resource:testIamPermissions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"permissions\": []\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  \"permissions\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:resource:testIamPermissions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:resource:testIamPermissions")
  .header("content-type", "application/json")
  .body("{\n  \"permissions\": []\n}")
  .asString();

const data = JSON.stringify({
  permissions: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1beta1/:resource:testIamPermissions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:resource:testIamPermissions',
  headers: {'content-type': 'application/json'},
  data: {permissions: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta1/:resource:testIamPermissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissions":[]}'
};

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}}/v1beta1/:resource:testIamPermissions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "permissions": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"permissions\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:resource:testIamPermissions")
  .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/v1beta1/:resource:testIamPermissions',
  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({permissions: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:resource:testIamPermissions',
  headers: {'content-type': 'application/json'},
  body: {permissions: []},
  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}}/v1beta1/:resource:testIamPermissions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  permissions: []
});

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}}/v1beta1/:resource:testIamPermissions',
  headers: {'content-type': 'application/json'},
  data: {permissions: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta1/:resource:testIamPermissions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"permissions":[]}'
};

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 = @{ @"permissions": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:resource:testIamPermissions"]
                                                       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}}/v1beta1/:resource:testIamPermissions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"permissions\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta1/:resource:testIamPermissions",
  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([
    'permissions' => [
        
    ]
  ]),
  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}}/v1beta1/:resource:testIamPermissions', [
  'body' => '{
  "permissions": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:resource:testIamPermissions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'permissions' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'permissions' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:resource:testIamPermissions');
$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}}/v1beta1/:resource:testIamPermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissions": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:resource:testIamPermissions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "permissions": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"permissions\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1beta1/:resource:testIamPermissions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta1/:resource:testIamPermissions"

payload = { "permissions": [] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:resource:testIamPermissions"

payload <- "{\n  \"permissions\": []\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}}/v1beta1/:resource:testIamPermissions")

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  \"permissions\": []\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/v1beta1/:resource:testIamPermissions') do |req|
  req.body = "{\n  \"permissions\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta1/:resource:testIamPermissions";

    let payload = json!({"permissions": ()});

    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}}/v1beta1/:resource:testIamPermissions \
  --header 'content-type: application/json' \
  --data '{
  "permissions": []
}'

echo '{
  "permissions": []
}' |  \
  http POST {{baseUrl}}/v1beta1/:resource:testIamPermissions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "permissions": []\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:resource:testIamPermissions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["permissions": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:resource:testIamPermissions")! 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 dataform.projects.locations.repositories.workspaces.writeFile

{{baseUrl}}/v1beta1/:workspace:writeFile

QUERY PARAMS

workspace

BODY json

{
  "contents": "",
  "path": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta1/:workspace:writeFile");

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  \"contents\": \"\",\n  \"path\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1beta1/:workspace:writeFile" {:content-type :json
                                                                         :form-params {:contents ""
                                                                                       :path ""}})

require "http/client"

url = "{{baseUrl}}/v1beta1/:workspace:writeFile"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"contents\": \"\",\n  \"path\": \"\"\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}}/v1beta1/:workspace:writeFile"),
    Content = new StringContent("{\n  \"contents\": \"\",\n  \"path\": \"\"\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}}/v1beta1/:workspace:writeFile");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"contents\": \"\",\n  \"path\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta1/:workspace:writeFile"

	payload := strings.NewReader("{\n  \"contents\": \"\",\n  \"path\": \"\"\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/v1beta1/:workspace:writeFile HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "contents": "",
  "path": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta1/:workspace:writeFile")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"contents\": \"\",\n  \"path\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta1/:workspace:writeFile"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"contents\": \"\",\n  \"path\": \"\"\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  \"contents\": \"\",\n  \"path\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:writeFile")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta1/:workspace:writeFile")
  .header("content-type", "application/json")
  .body("{\n  \"contents\": \"\",\n  \"path\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  contents: '',
  path: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1beta1/:workspace:writeFile');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:writeFile',
  headers: {'content-type': 'application/json'},
  data: {contents: '', path: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta1/:workspace:writeFile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contents":"","path":""}'
};

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}}/v1beta1/:workspace:writeFile',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "contents": "",\n  "path": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"contents\": \"\",\n  \"path\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta1/:workspace:writeFile")
  .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/v1beta1/:workspace:writeFile',
  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({contents: '', path: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta1/:workspace:writeFile',
  headers: {'content-type': 'application/json'},
  body: {contents: '', path: ''},
  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}}/v1beta1/:workspace:writeFile');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  contents: '',
  path: ''
});

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}}/v1beta1/:workspace:writeFile',
  headers: {'content-type': 'application/json'},
  data: {contents: '', path: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta1/:workspace:writeFile';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"contents":"","path":""}'
};

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 = @{ @"contents": @"",
                              @"path": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta1/:workspace:writeFile"]
                                                       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}}/v1beta1/:workspace:writeFile" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"contents\": \"\",\n  \"path\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta1/:workspace:writeFile",
  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([
    'contents' => '',
    'path' => ''
  ]),
  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}}/v1beta1/:workspace:writeFile', [
  'body' => '{
  "contents": "",
  "path": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta1/:workspace:writeFile');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'contents' => '',
  'path' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'contents' => '',
  'path' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta1/:workspace:writeFile');
$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}}/v1beta1/:workspace:writeFile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contents": "",
  "path": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta1/:workspace:writeFile' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "contents": "",
  "path": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"contents\": \"\",\n  \"path\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1beta1/:workspace:writeFile", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta1/:workspace:writeFile"

payload = {
    "contents": "",
    "path": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta1/:workspace:writeFile"

payload <- "{\n  \"contents\": \"\",\n  \"path\": \"\"\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}}/v1beta1/:workspace:writeFile")

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  \"contents\": \"\",\n  \"path\": \"\"\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/v1beta1/:workspace:writeFile') do |req|
  req.body = "{\n  \"contents\": \"\",\n  \"path\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta1/:workspace:writeFile";

    let payload = json!({
        "contents": "",
        "path": ""
    });

    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}}/v1beta1/:workspace:writeFile \
  --header 'content-type: application/json' \
  --data '{
  "contents": "",
  "path": ""
}'

echo '{
  "contents": "",
  "path": ""
}' |  \
  http POST {{baseUrl}}/v1beta1/:workspace:writeFile \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "contents": "",\n  "path": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta1/:workspace:writeFile

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "contents": "",
  "path": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta1/:workspace:writeFile")! 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()