App Engine Admin API

POST appengine.apps.authorizedCertificates.create

{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates

QUERY PARAMS

appsId

BODY json

{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates");

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  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates" {:content-type :json
                                                                                       :form-params {:certificateRawData {:privateKey ""
                                                                                                                          :publicCertificate ""}
                                                                                                     :displayName ""
                                                                                                     :domainMappingsCount 0
                                                                                                     :domainNames []
                                                                                                     :expireTime ""
                                                                                                     :id ""
                                                                                                     :managedCertificate {:lastRenewalTime ""
                                                                                                                          :status ""}
                                                                                                     :name ""
                                                                                                     :visibleDomainMappings []}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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}}/v1beta/apps/:appsId/authorizedCertificates"),
    Content = new StringContent("{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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}}/v1beta/apps/:appsId/authorizedCertificates");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates"

	payload := strings.NewReader("{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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/v1beta/apps/:appsId/authorizedCertificates HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 305

{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates")
  .header("content-type", "application/json")
  .body("{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}")
  .asString();

const data = JSON.stringify({
  certificateRawData: {
    privateKey: '',
    publicCertificate: ''
  },
  displayName: '',
  domainMappingsCount: 0,
  domainNames: [],
  expireTime: '',
  id: '',
  managedCertificate: {
    lastRenewalTime: '',
    status: ''
  },
  name: '',
  visibleDomainMappings: []
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates',
  headers: {'content-type': 'application/json'},
  data: {
    certificateRawData: {privateKey: '', publicCertificate: ''},
    displayName: '',
    domainMappingsCount: 0,
    domainNames: [],
    expireTime: '',
    id: '',
    managedCertificate: {lastRenewalTime: '', status: ''},
    name: '',
    visibleDomainMappings: []
  }
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"certificateRawData":{"privateKey":"","publicCertificate":""},"displayName":"","domainMappingsCount":0,"domainNames":[],"expireTime":"","id":"","managedCertificate":{"lastRenewalTime":"","status":""},"name":"","visibleDomainMappings":[]}'
};

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}}/v1beta/apps/:appsId/authorizedCertificates',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "certificateRawData": {\n    "privateKey": "",\n    "publicCertificate": ""\n  },\n  "displayName": "",\n  "domainMappingsCount": 0,\n  "domainNames": [],\n  "expireTime": "",\n  "id": "",\n  "managedCertificate": {\n    "lastRenewalTime": "",\n    "status": ""\n  },\n  "name": "",\n  "visibleDomainMappings": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates")
  .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/v1beta/apps/:appsId/authorizedCertificates',
  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({
  certificateRawData: {privateKey: '', publicCertificate: ''},
  displayName: '',
  domainMappingsCount: 0,
  domainNames: [],
  expireTime: '',
  id: '',
  managedCertificate: {lastRenewalTime: '', status: ''},
  name: '',
  visibleDomainMappings: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates',
  headers: {'content-type': 'application/json'},
  body: {
    certificateRawData: {privateKey: '', publicCertificate: ''},
    displayName: '',
    domainMappingsCount: 0,
    domainNames: [],
    expireTime: '',
    id: '',
    managedCertificate: {lastRenewalTime: '', status: ''},
    name: '',
    visibleDomainMappings: []
  },
  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}}/v1beta/apps/:appsId/authorizedCertificates');

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

req.type('json');
req.send({
  certificateRawData: {
    privateKey: '',
    publicCertificate: ''
  },
  displayName: '',
  domainMappingsCount: 0,
  domainNames: [],
  expireTime: '',
  id: '',
  managedCertificate: {
    lastRenewalTime: '',
    status: ''
  },
  name: '',
  visibleDomainMappings: []
});

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}}/v1beta/apps/:appsId/authorizedCertificates',
  headers: {'content-type': 'application/json'},
  data: {
    certificateRawData: {privateKey: '', publicCertificate: ''},
    displayName: '',
    domainMappingsCount: 0,
    domainNames: [],
    expireTime: '',
    id: '',
    managedCertificate: {lastRenewalTime: '', status: ''},
    name: '',
    visibleDomainMappings: []
  }
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"certificateRawData":{"privateKey":"","publicCertificate":""},"displayName":"","domainMappingsCount":0,"domainNames":[],"expireTime":"","id":"","managedCertificate":{"lastRenewalTime":"","status":""},"name":"","visibleDomainMappings":[]}'
};

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 = @{ @"certificateRawData": @{ @"privateKey": @"", @"publicCertificate": @"" },
                              @"displayName": @"",
                              @"domainMappingsCount": @0,
                              @"domainNames": @[  ],
                              @"expireTime": @"",
                              @"id": @"",
                              @"managedCertificate": @{ @"lastRenewalTime": @"", @"status": @"" },
                              @"name": @"",
                              @"visibleDomainMappings": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates"]
                                                       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}}/v1beta/apps/:appsId/authorizedCertificates" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates",
  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([
    'certificateRawData' => [
        'privateKey' => '',
        'publicCertificate' => ''
    ],
    'displayName' => '',
    'domainMappingsCount' => 0,
    'domainNames' => [
        
    ],
    'expireTime' => '',
    'id' => '',
    'managedCertificate' => [
        'lastRenewalTime' => '',
        'status' => ''
    ],
    'name' => '',
    'visibleDomainMappings' => [
        
    ]
  ]),
  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}}/v1beta/apps/:appsId/authorizedCertificates', [
  'body' => '{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'certificateRawData' => [
    'privateKey' => '',
    'publicCertificate' => ''
  ],
  'displayName' => '',
  'domainMappingsCount' => 0,
  'domainNames' => [
    
  ],
  'expireTime' => '',
  'id' => '',
  'managedCertificate' => [
    'lastRenewalTime' => '',
    'status' => ''
  ],
  'name' => '',
  'visibleDomainMappings' => [
    
  ]
]));

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

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

append(json_encode([
  'certificateRawData' => [
    'privateKey' => '',
    'publicCertificate' => ''
  ],
  'displayName' => '',
  'domainMappingsCount' => 0,
  'domainNames' => [
    
  ],
  'expireTime' => '',
  'id' => '',
  'managedCertificate' => [
    'lastRenewalTime' => '',
    'status' => ''
  ],
  'name' => '',
  'visibleDomainMappings' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates');
$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}}/v1beta/apps/:appsId/authorizedCertificates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}'

import http.client

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

payload = "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}"

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

conn.request("POST", "/baseUrl/v1beta/apps/:appsId/authorizedCertificates", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates"

payload = {
    "certificateRawData": {
        "privateKey": "",
        "publicCertificate": ""
    },
    "displayName": "",
    "domainMappingsCount": 0,
    "domainNames": [],
    "expireTime": "",
    "id": "",
    "managedCertificate": {
        "lastRenewalTime": "",
        "status": ""
    },
    "name": "",
    "visibleDomainMappings": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates"

payload <- "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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}}/v1beta/apps/:appsId/authorizedCertificates")

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  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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/v1beta/apps/:appsId/authorizedCertificates') do |req|
  req.body = "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "certificateRawData": json!({
            "privateKey": "",
            "publicCertificate": ""
        }),
        "displayName": "",
        "domainMappingsCount": 0,
        "domainNames": (),
        "expireTime": "",
        "id": "",
        "managedCertificate": json!({
            "lastRenewalTime": "",
            "status": ""
        }),
        "name": "",
        "visibleDomainMappings": ()
    });

    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}}/v1beta/apps/:appsId/authorizedCertificates \
  --header 'content-type: application/json' \
  --data '{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}'

echo '{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}' |  \
  http POST {{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "certificateRawData": {\n    "privateKey": "",\n    "publicCertificate": ""\n  },\n  "displayName": "",\n  "domainMappingsCount": 0,\n  "domainNames": [],\n  "expireTime": "",\n  "id": "",\n  "managedCertificate": {\n    "lastRenewalTime": "",\n    "status": ""\n  },\n  "name": "",\n  "visibleDomainMappings": []\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "certificateRawData": [
    "privateKey": "",
    "publicCertificate": ""
  ],
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": [
    "lastRenewalTime": "",
    "status": ""
  ],
  "name": "",
  "visibleDomainMappings": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates")! 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 appengine.apps.authorizedCertificates.delete

{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId

QUERY PARAMS

appsId

authorizedCertificatesId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"

	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/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"))
    .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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId';
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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId',
  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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');

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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId';
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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"]
                                                       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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId",
  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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")

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/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId";

    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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId

http DELETE {{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")! 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 appengine.apps.authorizedCertificates.get

{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId

QUERY PARAMS

appsId

authorizedCertificatesId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"

	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/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"))
    .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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId';
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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId',
  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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');

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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId';
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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"]
                                                       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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId",
  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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")

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/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId";

    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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId

http GET {{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")! 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 appengine.apps.authorizedCertificates.list

{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates

QUERY PARAMS

appsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates"

	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/v1beta/apps/:appsId/authorizedCertificates HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates"))
    .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}}/v1beta/apps/:appsId/authorizedCertificates")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates")
  .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}}/v1beta/apps/:appsId/authorizedCertificates');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates';
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}}/v1beta/apps/:appsId/authorizedCertificates',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates');

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}}/v1beta/apps/:appsId/authorizedCertificates'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates';
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}}/v1beta/apps/:appsId/authorizedCertificates"]
                                                       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}}/v1beta/apps/:appsId/authorizedCertificates" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates",
  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}}/v1beta/apps/:appsId/authorizedCertificates');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/authorizedCertificates")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates")

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/v1beta/apps/:appsId/authorizedCertificates') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta/apps/:appsId/authorizedCertificates

http GET {{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates")! 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 appengine.apps.authorizedCertificates.patch

{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId

QUERY PARAMS

appsId

authorizedCertificatesId

BODY json

{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId");

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  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId" {:content-type :json
                                                                                                                  :form-params {:certificateRawData {:privateKey ""
                                                                                                                                                     :publicCertificate ""}
                                                                                                                                :displayName ""
                                                                                                                                :domainMappingsCount 0
                                                                                                                                :domainNames []
                                                                                                                                :expireTime ""
                                                                                                                                :id ""
                                                                                                                                :managedCertificate {:lastRenewalTime ""
                                                                                                                                                     :status ""}
                                                                                                                                :name ""
                                                                                                                                :visibleDomainMappings []}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"),
    Content = new StringContent("{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"

	payload := strings.NewReader("{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 305

{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .header("content-type", "application/json")
  .body("{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}")
  .asString();

const data = JSON.stringify({
  certificateRawData: {
    privateKey: '',
    publicCertificate: ''
  },
  displayName: '',
  domainMappingsCount: 0,
  domainNames: [],
  expireTime: '',
  id: '',
  managedCertificate: {
    lastRenewalTime: '',
    status: ''
  },
  name: '',
  visibleDomainMappings: []
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId',
  headers: {'content-type': 'application/json'},
  data: {
    certificateRawData: {privateKey: '', publicCertificate: ''},
    displayName: '',
    domainMappingsCount: 0,
    domainNames: [],
    expireTime: '',
    id: '',
    managedCertificate: {lastRenewalTime: '', status: ''},
    name: '',
    visibleDomainMappings: []
  }
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"certificateRawData":{"privateKey":"","publicCertificate":""},"displayName":"","domainMappingsCount":0,"domainNames":[],"expireTime":"","id":"","managedCertificate":{"lastRenewalTime":"","status":""},"name":"","visibleDomainMappings":[]}'
};

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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "certificateRawData": {\n    "privateKey": "",\n    "publicCertificate": ""\n  },\n  "displayName": "",\n  "domainMappingsCount": 0,\n  "domainNames": [],\n  "expireTime": "",\n  "id": "",\n  "managedCertificate": {\n    "lastRenewalTime": "",\n    "status": ""\n  },\n  "name": "",\n  "visibleDomainMappings": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")
  .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/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId',
  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({
  certificateRawData: {privateKey: '', publicCertificate: ''},
  displayName: '',
  domainMappingsCount: 0,
  domainNames: [],
  expireTime: '',
  id: '',
  managedCertificate: {lastRenewalTime: '', status: ''},
  name: '',
  visibleDomainMappings: []
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId',
  headers: {'content-type': 'application/json'},
  body: {
    certificateRawData: {privateKey: '', publicCertificate: ''},
    displayName: '',
    domainMappingsCount: 0,
    domainNames: [],
    expireTime: '',
    id: '',
    managedCertificate: {lastRenewalTime: '', status: ''},
    name: '',
    visibleDomainMappings: []
  },
  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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');

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

req.type('json');
req.send({
  certificateRawData: {
    privateKey: '',
    publicCertificate: ''
  },
  displayName: '',
  domainMappingsCount: 0,
  domainNames: [],
  expireTime: '',
  id: '',
  managedCertificate: {
    lastRenewalTime: '',
    status: ''
  },
  name: '',
  visibleDomainMappings: []
});

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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId',
  headers: {'content-type': 'application/json'},
  data: {
    certificateRawData: {privateKey: '', publicCertificate: ''},
    displayName: '',
    domainMappingsCount: 0,
    domainNames: [],
    expireTime: '',
    id: '',
    managedCertificate: {lastRenewalTime: '', status: ''},
    name: '',
    visibleDomainMappings: []
  }
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"certificateRawData":{"privateKey":"","publicCertificate":""},"displayName":"","domainMappingsCount":0,"domainNames":[],"expireTime":"","id":"","managedCertificate":{"lastRenewalTime":"","status":""},"name":"","visibleDomainMappings":[]}'
};

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 = @{ @"certificateRawData": @{ @"privateKey": @"", @"publicCertificate": @"" },
                              @"displayName": @"",
                              @"domainMappingsCount": @0,
                              @"domainNames": @[  ],
                              @"expireTime": @"",
                              @"id": @"",
                              @"managedCertificate": @{ @"lastRenewalTime": @"", @"status": @"" },
                              @"name": @"",
                              @"visibleDomainMappings": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"]
                                                       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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId",
  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([
    'certificateRawData' => [
        'privateKey' => '',
        'publicCertificate' => ''
    ],
    'displayName' => '',
    'domainMappingsCount' => 0,
    'domainNames' => [
        
    ],
    'expireTime' => '',
    'id' => '',
    'managedCertificate' => [
        'lastRenewalTime' => '',
        'status' => ''
    ],
    'name' => '',
    'visibleDomainMappings' => [
        
    ]
  ]),
  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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId', [
  'body' => '{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'certificateRawData' => [
    'privateKey' => '',
    'publicCertificate' => ''
  ],
  'displayName' => '',
  'domainMappingsCount' => 0,
  'domainNames' => [
    
  ],
  'expireTime' => '',
  'id' => '',
  'managedCertificate' => [
    'lastRenewalTime' => '',
    'status' => ''
  ],
  'name' => '',
  'visibleDomainMappings' => [
    
  ]
]));

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

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

append(json_encode([
  'certificateRawData' => [
    'privateKey' => '',
    'publicCertificate' => ''
  ],
  'displayName' => '',
  'domainMappingsCount' => 0,
  'domainNames' => [
    
  ],
  'expireTime' => '',
  'id' => '',
  'managedCertificate' => [
    'lastRenewalTime' => '',
    'status' => ''
  ],
  'name' => '',
  'visibleDomainMappings' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId');
$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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}'

import http.client

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

payload = "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\n}"

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

conn.request("PATCH", "/baseUrl/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"

payload = {
    "certificateRawData": {
        "privateKey": "",
        "publicCertificate": ""
    },
    "displayName": "",
    "domainMappingsCount": 0,
    "domainNames": [],
    "expireTime": "",
    "id": "",
    "managedCertificate": {
        "lastRenewalTime": "",
        "status": ""
    },
    "name": "",
    "visibleDomainMappings": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId"

payload <- "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")

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  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId') do |req|
  req.body = "{\n  \"certificateRawData\": {\n    \"privateKey\": \"\",\n    \"publicCertificate\": \"\"\n  },\n  \"displayName\": \"\",\n  \"domainMappingsCount\": 0,\n  \"domainNames\": [],\n  \"expireTime\": \"\",\n  \"id\": \"\",\n  \"managedCertificate\": {\n    \"lastRenewalTime\": \"\",\n    \"status\": \"\"\n  },\n  \"name\": \"\",\n  \"visibleDomainMappings\": []\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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId";

    let payload = json!({
        "certificateRawData": json!({
            "privateKey": "",
            "publicCertificate": ""
        }),
        "displayName": "",
        "domainMappingsCount": 0,
        "domainNames": (),
        "expireTime": "",
        "id": "",
        "managedCertificate": json!({
            "lastRenewalTime": "",
            "status": ""
        }),
        "name": "",
        "visibleDomainMappings": ()
    });

    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}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId \
  --header 'content-type: application/json' \
  --data '{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}'

echo '{
  "certificateRawData": {
    "privateKey": "",
    "publicCertificate": ""
  },
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": {
    "lastRenewalTime": "",
    "status": ""
  },
  "name": "",
  "visibleDomainMappings": []
}' |  \
  http PATCH {{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "certificateRawData": {\n    "privateKey": "",\n    "publicCertificate": ""\n  },\n  "displayName": "",\n  "domainMappingsCount": 0,\n  "domainNames": [],\n  "expireTime": "",\n  "id": "",\n  "managedCertificate": {\n    "lastRenewalTime": "",\n    "status": ""\n  },\n  "name": "",\n  "visibleDomainMappings": []\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "certificateRawData": [
    "privateKey": "",
    "publicCertificate": ""
  ],
  "displayName": "",
  "domainMappingsCount": 0,
  "domainNames": [],
  "expireTime": "",
  "id": "",
  "managedCertificate": [
    "lastRenewalTime": "",
    "status": ""
  ],
  "name": "",
  "visibleDomainMappings": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/authorizedCertificates/:authorizedCertificatesId")! 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()

GET appengine.apps.authorizedDomains.list

{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains

QUERY PARAMS

appsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains"

	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/v1beta/apps/:appsId/authorizedDomains HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains"))
    .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}}/v1beta/apps/:appsId/authorizedDomains")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains")
  .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}}/v1beta/apps/:appsId/authorizedDomains');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains';
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}}/v1beta/apps/:appsId/authorizedDomains',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains');

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}}/v1beta/apps/:appsId/authorizedDomains'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains';
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}}/v1beta/apps/:appsId/authorizedDomains"]
                                                       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}}/v1beta/apps/:appsId/authorizedDomains" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains",
  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}}/v1beta/apps/:appsId/authorizedDomains');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/authorizedDomains")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains")

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/v1beta/apps/:appsId/authorizedDomains') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta/apps/:appsId/authorizedDomains

http GET {{baseUrl}}/v1beta/apps/:appsId/authorizedDomains

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/authorizedDomains

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/authorizedDomains")! 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 appengine.apps.create

{{baseUrl}}/v1beta/apps

BODY json

{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/apps" {:content-type :json
                                                        :form-params {:authDomain ""
                                                                      :codeBucket ""
                                                                      :databaseType ""
                                                                      :defaultBucket ""
                                                                      :defaultCookieExpiration ""
                                                                      :defaultHostname ""
                                                                      :dispatchRules [{:domain ""
                                                                                       :path ""
                                                                                       :service ""}]
                                                                      :featureSettings {:splitHealthChecks false
                                                                                        :useContainerOptimizedOs false}
                                                                      :gcrDomain ""
                                                                      :iap {:enabled false
                                                                            :oauth2ClientId ""
                                                                            :oauth2ClientSecret ""
                                                                            :oauth2ClientSecretSha256 ""}
                                                                      :id ""
                                                                      :locationId ""
                                                                      :name ""
                                                                      :serviceAccount ""
                                                                      :servingStatus ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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}}/v1beta/apps"),
    Content = new StringContent("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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}}/v1beta/apps");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps"

	payload := strings.NewReader("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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/v1beta/apps HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 579

{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/apps")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/apps")
  .header("content-type", "application/json")
  .body("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  authDomain: '',
  codeBucket: '',
  databaseType: '',
  defaultBucket: '',
  defaultCookieExpiration: '',
  defaultHostname: '',
  dispatchRules: [
    {
      domain: '',
      path: '',
      service: ''
    }
  ],
  featureSettings: {
    splitHealthChecks: false,
    useContainerOptimizedOs: false
  },
  gcrDomain: '',
  iap: {
    enabled: false,
    oauth2ClientId: '',
    oauth2ClientSecret: '',
    oauth2ClientSecretSha256: ''
  },
  id: '',
  locationId: '',
  name: '',
  serviceAccount: '',
  servingStatus: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps',
  headers: {'content-type': 'application/json'},
  data: {
    authDomain: '',
    codeBucket: '',
    databaseType: '',
    defaultBucket: '',
    defaultCookieExpiration: '',
    defaultHostname: '',
    dispatchRules: [{domain: '', path: '', service: ''}],
    featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
    gcrDomain: '',
    iap: {
      enabled: false,
      oauth2ClientId: '',
      oauth2ClientSecret: '',
      oauth2ClientSecretSha256: ''
    },
    id: '',
    locationId: '',
    name: '',
    serviceAccount: '',
    servingStatus: ''
  }
};

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

const url = '{{baseUrl}}/v1beta/apps';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authDomain":"","codeBucket":"","databaseType":"","defaultBucket":"","defaultCookieExpiration":"","defaultHostname":"","dispatchRules":[{"domain":"","path":"","service":""}],"featureSettings":{"splitHealthChecks":false,"useContainerOptimizedOs":false},"gcrDomain":"","iap":{"enabled":false,"oauth2ClientId":"","oauth2ClientSecret":"","oauth2ClientSecretSha256":""},"id":"","locationId":"","name":"","serviceAccount":"","servingStatus":""}'
};

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}}/v1beta/apps',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authDomain": "",\n  "codeBucket": "",\n  "databaseType": "",\n  "defaultBucket": "",\n  "defaultCookieExpiration": "",\n  "defaultHostname": "",\n  "dispatchRules": [\n    {\n      "domain": "",\n      "path": "",\n      "service": ""\n    }\n  ],\n  "featureSettings": {\n    "splitHealthChecks": false,\n    "useContainerOptimizedOs": false\n  },\n  "gcrDomain": "",\n  "iap": {\n    "enabled": false,\n    "oauth2ClientId": "",\n    "oauth2ClientSecret": "",\n    "oauth2ClientSecretSha256": ""\n  },\n  "id": "",\n  "locationId": "",\n  "name": "",\n  "serviceAccount": "",\n  "servingStatus": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps")
  .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/v1beta/apps',
  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({
  authDomain: '',
  codeBucket: '',
  databaseType: '',
  defaultBucket: '',
  defaultCookieExpiration: '',
  defaultHostname: '',
  dispatchRules: [{domain: '', path: '', service: ''}],
  featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
  gcrDomain: '',
  iap: {
    enabled: false,
    oauth2ClientId: '',
    oauth2ClientSecret: '',
    oauth2ClientSecretSha256: ''
  },
  id: '',
  locationId: '',
  name: '',
  serviceAccount: '',
  servingStatus: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps',
  headers: {'content-type': 'application/json'},
  body: {
    authDomain: '',
    codeBucket: '',
    databaseType: '',
    defaultBucket: '',
    defaultCookieExpiration: '',
    defaultHostname: '',
    dispatchRules: [{domain: '', path: '', service: ''}],
    featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
    gcrDomain: '',
    iap: {
      enabled: false,
      oauth2ClientId: '',
      oauth2ClientSecret: '',
      oauth2ClientSecretSha256: ''
    },
    id: '',
    locationId: '',
    name: '',
    serviceAccount: '',
    servingStatus: ''
  },
  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}}/v1beta/apps');

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

req.type('json');
req.send({
  authDomain: '',
  codeBucket: '',
  databaseType: '',
  defaultBucket: '',
  defaultCookieExpiration: '',
  defaultHostname: '',
  dispatchRules: [
    {
      domain: '',
      path: '',
      service: ''
    }
  ],
  featureSettings: {
    splitHealthChecks: false,
    useContainerOptimizedOs: false
  },
  gcrDomain: '',
  iap: {
    enabled: false,
    oauth2ClientId: '',
    oauth2ClientSecret: '',
    oauth2ClientSecretSha256: ''
  },
  id: '',
  locationId: '',
  name: '',
  serviceAccount: '',
  servingStatus: ''
});

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}}/v1beta/apps',
  headers: {'content-type': 'application/json'},
  data: {
    authDomain: '',
    codeBucket: '',
    databaseType: '',
    defaultBucket: '',
    defaultCookieExpiration: '',
    defaultHostname: '',
    dispatchRules: [{domain: '', path: '', service: ''}],
    featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
    gcrDomain: '',
    iap: {
      enabled: false,
      oauth2ClientId: '',
      oauth2ClientSecret: '',
      oauth2ClientSecretSha256: ''
    },
    id: '',
    locationId: '',
    name: '',
    serviceAccount: '',
    servingStatus: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta/apps';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authDomain":"","codeBucket":"","databaseType":"","defaultBucket":"","defaultCookieExpiration":"","defaultHostname":"","dispatchRules":[{"domain":"","path":"","service":""}],"featureSettings":{"splitHealthChecks":false,"useContainerOptimizedOs":false},"gcrDomain":"","iap":{"enabled":false,"oauth2ClientId":"","oauth2ClientSecret":"","oauth2ClientSecretSha256":""},"id":"","locationId":"","name":"","serviceAccount":"","servingStatus":""}'
};

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 = @{ @"authDomain": @"",
                              @"codeBucket": @"",
                              @"databaseType": @"",
                              @"defaultBucket": @"",
                              @"defaultCookieExpiration": @"",
                              @"defaultHostname": @"",
                              @"dispatchRules": @[ @{ @"domain": @"", @"path": @"", @"service": @"" } ],
                              @"featureSettings": @{ @"splitHealthChecks": @NO, @"useContainerOptimizedOs": @NO },
                              @"gcrDomain": @"",
                              @"iap": @{ @"enabled": @NO, @"oauth2ClientId": @"", @"oauth2ClientSecret": @"", @"oauth2ClientSecretSha256": @"" },
                              @"id": @"",
                              @"locationId": @"",
                              @"name": @"",
                              @"serviceAccount": @"",
                              @"servingStatus": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps"]
                                                       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}}/v1beta/apps" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/apps",
  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([
    'authDomain' => '',
    'codeBucket' => '',
    'databaseType' => '',
    'defaultBucket' => '',
    'defaultCookieExpiration' => '',
    'defaultHostname' => '',
    'dispatchRules' => [
        [
                'domain' => '',
                'path' => '',
                'service' => ''
        ]
    ],
    'featureSettings' => [
        'splitHealthChecks' => null,
        'useContainerOptimizedOs' => null
    ],
    'gcrDomain' => '',
    'iap' => [
        'enabled' => null,
        'oauth2ClientId' => '',
        'oauth2ClientSecret' => '',
        'oauth2ClientSecretSha256' => ''
    ],
    'id' => '',
    'locationId' => '',
    'name' => '',
    'serviceAccount' => '',
    'servingStatus' => ''
  ]),
  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}}/v1beta/apps', [
  'body' => '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authDomain' => '',
  'codeBucket' => '',
  'databaseType' => '',
  'defaultBucket' => '',
  'defaultCookieExpiration' => '',
  'defaultHostname' => '',
  'dispatchRules' => [
    [
        'domain' => '',
        'path' => '',
        'service' => ''
    ]
  ],
  'featureSettings' => [
    'splitHealthChecks' => null,
    'useContainerOptimizedOs' => null
  ],
  'gcrDomain' => '',
  'iap' => [
    'enabled' => null,
    'oauth2ClientId' => '',
    'oauth2ClientSecret' => '',
    'oauth2ClientSecretSha256' => ''
  ],
  'id' => '',
  'locationId' => '',
  'name' => '',
  'serviceAccount' => '',
  'servingStatus' => ''
]));

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

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

append(json_encode([
  'authDomain' => '',
  'codeBucket' => '',
  'databaseType' => '',
  'defaultBucket' => '',
  'defaultCookieExpiration' => '',
  'defaultHostname' => '',
  'dispatchRules' => [
    [
        'domain' => '',
        'path' => '',
        'service' => ''
    ]
  ],
  'featureSettings' => [
    'splitHealthChecks' => null,
    'useContainerOptimizedOs' => null
  ],
  'gcrDomain' => '',
  'iap' => [
    'enabled' => null,
    'oauth2ClientId' => '',
    'oauth2ClientSecret' => '',
    'oauth2ClientSecretSha256' => ''
  ],
  'id' => '',
  'locationId' => '',
  'name' => '',
  'serviceAccount' => '',
  'servingStatus' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps');
$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}}/v1beta/apps' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}'

import http.client

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

payload = "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/v1beta/apps"

payload = {
    "authDomain": "",
    "codeBucket": "",
    "databaseType": "",
    "defaultBucket": "",
    "defaultCookieExpiration": "",
    "defaultHostname": "",
    "dispatchRules": [
        {
            "domain": "",
            "path": "",
            "service": ""
        }
    ],
    "featureSettings": {
        "splitHealthChecks": False,
        "useContainerOptimizedOs": False
    },
    "gcrDomain": "",
    "iap": {
        "enabled": False,
        "oauth2ClientId": "",
        "oauth2ClientSecret": "",
        "oauth2ClientSecretSha256": ""
    },
    "id": "",
    "locationId": "",
    "name": "",
    "serviceAccount": "",
    "servingStatus": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps"

payload <- "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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}}/v1beta/apps")

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  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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/v1beta/apps') do |req|
  req.body = "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "authDomain": "",
        "codeBucket": "",
        "databaseType": "",
        "defaultBucket": "",
        "defaultCookieExpiration": "",
        "defaultHostname": "",
        "dispatchRules": (
            json!({
                "domain": "",
                "path": "",
                "service": ""
            })
        ),
        "featureSettings": json!({
            "splitHealthChecks": false,
            "useContainerOptimizedOs": false
        }),
        "gcrDomain": "",
        "iap": json!({
            "enabled": false,
            "oauth2ClientId": "",
            "oauth2ClientSecret": "",
            "oauth2ClientSecretSha256": ""
        }),
        "id": "",
        "locationId": "",
        "name": "",
        "serviceAccount": "",
        "servingStatus": ""
    });

    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}}/v1beta/apps \
  --header 'content-type: application/json' \
  --data '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}'

echo '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}' |  \
  http POST {{baseUrl}}/v1beta/apps \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authDomain": "",\n  "codeBucket": "",\n  "databaseType": "",\n  "defaultBucket": "",\n  "defaultCookieExpiration": "",\n  "defaultHostname": "",\n  "dispatchRules": [\n    {\n      "domain": "",\n      "path": "",\n      "service": ""\n    }\n  ],\n  "featureSettings": {\n    "splitHealthChecks": false,\n    "useContainerOptimizedOs": false\n  },\n  "gcrDomain": "",\n  "iap": {\n    "enabled": false,\n    "oauth2ClientId": "",\n    "oauth2ClientSecret": "",\n    "oauth2ClientSecretSha256": ""\n  },\n  "id": "",\n  "locationId": "",\n  "name": "",\n  "serviceAccount": "",\n  "servingStatus": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    [
      "domain": "",
      "path": "",
      "service": ""
    ]
  ],
  "featureSettings": [
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  ],
  "gcrDomain": "",
  "iap": [
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  ],
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps")! 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 appengine.apps.domainMappings.create

{{baseUrl}}/v1beta/apps/:appsId/domainMappings

QUERY PARAMS

appsId

BODY json

{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/domainMappings");

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  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/apps/:appsId/domainMappings" {:content-type :json
                                                                               :form-params {:id ""
                                                                                             :name ""
                                                                                             :resourceRecords [{:name ""
                                                                                                                :rrdata ""
                                                                                                                :type ""}]
                                                                                             :sslSettings {:certificateId ""
                                                                                                           :pendingManagedCertificateId ""
                                                                                                           :sslManagementType ""}}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\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}}/v1beta/apps/:appsId/domainMappings"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\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}}/v1beta/apps/:appsId/domainMappings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/domainMappings"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\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/v1beta/apps/:appsId/domainMappings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 239

{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/apps/:appsId/domainMappings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/domainMappings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\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  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/domainMappings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/apps/:appsId/domainMappings")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  name: '',
  resourceRecords: [
    {
      name: '',
      rrdata: '',
      type: ''
    }
  ],
  sslSettings: {
    certificateId: '',
    pendingManagedCertificateId: '',
    sslManagementType: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta/apps/:appsId/domainMappings');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/domainMappings',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    name: '',
    resourceRecords: [{name: '', rrdata: '', type: ''}],
    sslSettings: {certificateId: '', pendingManagedCertificateId: '', sslManagementType: ''}
  }
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/domainMappings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","name":"","resourceRecords":[{"name":"","rrdata":"","type":""}],"sslSettings":{"certificateId":"","pendingManagedCertificateId":"","sslManagementType":""}}'
};

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}}/v1beta/apps/:appsId/domainMappings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "name": "",\n  "resourceRecords": [\n    {\n      "name": "",\n      "rrdata": "",\n      "type": ""\n    }\n  ],\n  "sslSettings": {\n    "certificateId": "",\n    "pendingManagedCertificateId": "",\n    "sslManagementType": ""\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  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/domainMappings")
  .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/v1beta/apps/:appsId/domainMappings',
  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({
  id: '',
  name: '',
  resourceRecords: [{name: '', rrdata: '', type: ''}],
  sslSettings: {certificateId: '', pendingManagedCertificateId: '', sslManagementType: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/domainMappings',
  headers: {'content-type': 'application/json'},
  body: {
    id: '',
    name: '',
    resourceRecords: [{name: '', rrdata: '', type: ''}],
    sslSettings: {certificateId: '', pendingManagedCertificateId: '', sslManagementType: ''}
  },
  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}}/v1beta/apps/:appsId/domainMappings');

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

req.type('json');
req.send({
  id: '',
  name: '',
  resourceRecords: [
    {
      name: '',
      rrdata: '',
      type: ''
    }
  ],
  sslSettings: {
    certificateId: '',
    pendingManagedCertificateId: '',
    sslManagementType: ''
  }
});

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}}/v1beta/apps/:appsId/domainMappings',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    name: '',
    resourceRecords: [{name: '', rrdata: '', type: ''}],
    sslSettings: {certificateId: '', pendingManagedCertificateId: '', sslManagementType: ''}
  }
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/domainMappings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","name":"","resourceRecords":[{"name":"","rrdata":"","type":""}],"sslSettings":{"certificateId":"","pendingManagedCertificateId":"","sslManagementType":""}}'
};

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 = @{ @"id": @"",
                              @"name": @"",
                              @"resourceRecords": @[ @{ @"name": @"", @"rrdata": @"", @"type": @"" } ],
                              @"sslSettings": @{ @"certificateId": @"", @"pendingManagedCertificateId": @"", @"sslManagementType": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/domainMappings"]
                                                       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}}/v1beta/apps/:appsId/domainMappings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/domainMappings",
  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([
    'id' => '',
    'name' => '',
    'resourceRecords' => [
        [
                'name' => '',
                'rrdata' => '',
                'type' => ''
        ]
    ],
    'sslSettings' => [
        'certificateId' => '',
        'pendingManagedCertificateId' => '',
        'sslManagementType' => ''
    ]
  ]),
  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}}/v1beta/apps/:appsId/domainMappings', [
  'body' => '{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/domainMappings');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'name' => '',
  'resourceRecords' => [
    [
        'name' => '',
        'rrdata' => '',
        'type' => ''
    ]
  ],
  'sslSettings' => [
    'certificateId' => '',
    'pendingManagedCertificateId' => '',
    'sslManagementType' => ''
  ]
]));

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

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

append(json_encode([
  'id' => '',
  'name' => '',
  'resourceRecords' => [
    [
        'name' => '',
        'rrdata' => '',
        'type' => ''
    ]
  ],
  'sslSettings' => [
    'certificateId' => '',
    'pendingManagedCertificateId' => '',
    'sslManagementType' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/domainMappings');
$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}}/v1beta/apps/:appsId/domainMappings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/domainMappings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}'

import http.client

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

payload = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1beta/apps/:appsId/domainMappings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings"

payload = {
    "id": "",
    "name": "",
    "resourceRecords": [
        {
            "name": "",
            "rrdata": "",
            "type": ""
        }
    ],
    "sslSettings": {
        "certificateId": "",
        "pendingManagedCertificateId": "",
        "sslManagementType": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/domainMappings"

payload <- "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\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}}/v1beta/apps/:appsId/domainMappings")

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  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\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/v1beta/apps/:appsId/domainMappings') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "id": "",
        "name": "",
        "resourceRecords": (
            json!({
                "name": "",
                "rrdata": "",
                "type": ""
            })
        ),
        "sslSettings": json!({
            "certificateId": "",
            "pendingManagedCertificateId": "",
            "sslManagementType": ""
        })
    });

    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}}/v1beta/apps/:appsId/domainMappings \
  --header 'content-type: application/json' \
  --data '{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}'

echo '{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}' |  \
  http POST {{baseUrl}}/v1beta/apps/:appsId/domainMappings \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "name": "",\n  "resourceRecords": [\n    {\n      "name": "",\n      "rrdata": "",\n      "type": ""\n    }\n  ],\n  "sslSettings": {\n    "certificateId": "",\n    "pendingManagedCertificateId": "",\n    "sslManagementType": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/domainMappings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": "",
  "name": "",
  "resourceRecords": [
    [
      "name": "",
      "rrdata": "",
      "type": ""
    ]
  ],
  "sslSettings": [
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/domainMappings")! 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 appengine.apps.domainMappings.delete

{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId

QUERY PARAMS

appsId

domainMappingsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"

	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/v1beta/apps/:appsId/domainMappings/:domainMappingsId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"))
    .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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId';
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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/domainMappings/:domainMappingsId',
  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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');

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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId';
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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"]
                                                       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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId",
  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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1beta/apps/:appsId/domainMappings/:domainMappingsId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")

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/v1beta/apps/:appsId/domainMappings/:domainMappingsId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId";

    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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId

http DELETE {{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")! 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 appengine.apps.domainMappings.get

{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId

QUERY PARAMS

appsId

domainMappingsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"

	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/v1beta/apps/:appsId/domainMappings/:domainMappingsId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"))
    .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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId';
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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/domainMappings/:domainMappingsId',
  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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');

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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId';
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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"]
                                                       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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId",
  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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/domainMappings/:domainMappingsId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")

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/v1beta/apps/:appsId/domainMappings/:domainMappingsId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId";

    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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId

http GET {{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")! 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 appengine.apps.domainMappings.list

{{baseUrl}}/v1beta/apps/:appsId/domainMappings

QUERY PARAMS

appsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/domainMappings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/domainMappings")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/domainMappings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/domainMappings"

	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/v1beta/apps/:appsId/domainMappings HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/domainMappings"))
    .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}}/v1beta/apps/:appsId/domainMappings")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/domainMappings")
  .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}}/v1beta/apps/:appsId/domainMappings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/domainMappings'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/domainMappings';
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}}/v1beta/apps/:appsId/domainMappings',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/domainMappings")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/domainMappings');

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}}/v1beta/apps/:appsId/domainMappings'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/domainMappings';
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}}/v1beta/apps/:appsId/domainMappings"]
                                                       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}}/v1beta/apps/:appsId/domainMappings" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/domainMappings",
  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}}/v1beta/apps/:appsId/domainMappings');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/domainMappings');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/domainMappings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/domainMappings' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/domainMappings' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/domainMappings")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/domainMappings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/domainMappings")

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/v1beta/apps/:appsId/domainMappings') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta/apps/:appsId/domainMappings

http GET {{baseUrl}}/v1beta/apps/:appsId/domainMappings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/domainMappings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/domainMappings")! 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 appengine.apps.domainMappings.patch

{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId

QUERY PARAMS

appsId

domainMappingsId

BODY json

{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId");

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  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId" {:content-type :json
                                                                                                  :form-params {:id ""
                                                                                                                :name ""
                                                                                                                :resourceRecords [{:name ""
                                                                                                                                   :rrdata ""
                                                                                                                                   :type ""}]
                                                                                                                :sslSettings {:certificateId ""
                                                                                                                              :pendingManagedCertificateId ""
                                                                                                                              :sslManagementType ""}}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\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/v1beta/apps/:appsId/domainMappings/:domainMappingsId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 239

{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\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  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  name: '',
  resourceRecords: [
    {
      name: '',
      rrdata: '',
      type: ''
    }
  ],
  sslSettings: {
    certificateId: '',
    pendingManagedCertificateId: '',
    sslManagementType: ''
  }
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    name: '',
    resourceRecords: [{name: '', rrdata: '', type: ''}],
    sslSettings: {certificateId: '', pendingManagedCertificateId: '', sslManagementType: ''}
  }
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","name":"","resourceRecords":[{"name":"","rrdata":"","type":""}],"sslSettings":{"certificateId":"","pendingManagedCertificateId":"","sslManagementType":""}}'
};

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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "name": "",\n  "resourceRecords": [\n    {\n      "name": "",\n      "rrdata": "",\n      "type": ""\n    }\n  ],\n  "sslSettings": {\n    "certificateId": "",\n    "pendingManagedCertificateId": "",\n    "sslManagementType": ""\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  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")
  .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/v1beta/apps/:appsId/domainMappings/:domainMappingsId',
  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({
  id: '',
  name: '',
  resourceRecords: [{name: '', rrdata: '', type: ''}],
  sslSettings: {certificateId: '', pendingManagedCertificateId: '', sslManagementType: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId',
  headers: {'content-type': 'application/json'},
  body: {
    id: '',
    name: '',
    resourceRecords: [{name: '', rrdata: '', type: ''}],
    sslSettings: {certificateId: '', pendingManagedCertificateId: '', sslManagementType: ''}
  },
  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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');

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

req.type('json');
req.send({
  id: '',
  name: '',
  resourceRecords: [
    {
      name: '',
      rrdata: '',
      type: ''
    }
  ],
  sslSettings: {
    certificateId: '',
    pendingManagedCertificateId: '',
    sslManagementType: ''
  }
});

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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    name: '',
    resourceRecords: [{name: '', rrdata: '', type: ''}],
    sslSettings: {certificateId: '', pendingManagedCertificateId: '', sslManagementType: ''}
  }
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","name":"","resourceRecords":[{"name":"","rrdata":"","type":""}],"sslSettings":{"certificateId":"","pendingManagedCertificateId":"","sslManagementType":""}}'
};

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 = @{ @"id": @"",
                              @"name": @"",
                              @"resourceRecords": @[ @{ @"name": @"", @"rrdata": @"", @"type": @"" } ],
                              @"sslSettings": @{ @"certificateId": @"", @"pendingManagedCertificateId": @"", @"sslManagementType": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"]
                                                       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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId",
  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([
    'id' => '',
    'name' => '',
    'resourceRecords' => [
        [
                'name' => '',
                'rrdata' => '',
                'type' => ''
        ]
    ],
    'sslSettings' => [
        'certificateId' => '',
        'pendingManagedCertificateId' => '',
        'sslManagementType' => ''
    ]
  ]),
  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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId', [
  'body' => '{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'name' => '',
  'resourceRecords' => [
    [
        'name' => '',
        'rrdata' => '',
        'type' => ''
    ]
  ],
  'sslSettings' => [
    'certificateId' => '',
    'pendingManagedCertificateId' => '',
    'sslManagementType' => ''
  ]
]));

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

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

append(json_encode([
  'id' => '',
  'name' => '',
  'resourceRecords' => [
    [
        'name' => '',
        'rrdata' => '',
        'type' => ''
    ]
  ],
  'sslSettings' => [
    'certificateId' => '',
    'pendingManagedCertificateId' => '',
    'sslManagementType' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId');
$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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}'

import http.client

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

payload = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}"

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

conn.request("PATCH", "/baseUrl/v1beta/apps/:appsId/domainMappings/:domainMappingsId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"

payload = {
    "id": "",
    "name": "",
    "resourceRecords": [
        {
            "name": "",
            "rrdata": "",
            "type": ""
        }
    ],
    "sslSettings": {
        "certificateId": "",
        "pendingManagedCertificateId": "",
        "sslManagementType": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId"

payload <- "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")

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  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\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.patch('/baseUrl/v1beta/apps/:appsId/domainMappings/:domainMappingsId') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"name\": \"\",\n  \"resourceRecords\": [\n    {\n      \"name\": \"\",\n      \"rrdata\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"sslSettings\": {\n    \"certificateId\": \"\",\n    \"pendingManagedCertificateId\": \"\",\n    \"sslManagementType\": \"\"\n  }\n}"
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId";

    let payload = json!({
        "id": "",
        "name": "",
        "resourceRecords": (
            json!({
                "name": "",
                "rrdata": "",
                "type": ""
            })
        ),
        "sslSettings": json!({
            "certificateId": "",
            "pendingManagedCertificateId": "",
            "sslManagementType": ""
        })
    });

    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}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId \
  --header 'content-type: application/json' \
  --data '{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}'

echo '{
  "id": "",
  "name": "",
  "resourceRecords": [
    {
      "name": "",
      "rrdata": "",
      "type": ""
    }
  ],
  "sslSettings": {
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  }
}' |  \
  http PATCH {{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "name": "",\n  "resourceRecords": [\n    {\n      "name": "",\n      "rrdata": "",\n      "type": ""\n    }\n  ],\n  "sslSettings": {\n    "certificateId": "",\n    "pendingManagedCertificateId": "",\n    "sslManagementType": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": "",
  "name": "",
  "resourceRecords": [
    [
      "name": "",
      "rrdata": "",
      "type": ""
    ]
  ],
  "sslSettings": [
    "certificateId": "",
    "pendingManagedCertificateId": "",
    "sslManagementType": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/domainMappings/:domainMappingsId")! 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 appengine.apps.firewall.ingressRules.batchUpdate

{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate

QUERY PARAMS

appsId

BODY json

{
  "ingressRules": [
    {
      "action": "",
      "description": "",
      "priority": 0,
      "sourceRange": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate" {:content-type :json
                                                                                                  :form-params {:ingressRules [{:action ""
                                                                                                                                :description ""
                                                                                                                                :priority 0
                                                                                                                                :sourceRange ""}]}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate"),
    Content = new StringContent("{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate"

	payload := strings.NewReader("{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 129

{
  "ingressRules": [
    {
      "action": "",
      "description": "",
      "priority": 0,
      "sourceRange": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate")
  .header("content-type", "application/json")
  .body("{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  ingressRules: [
    {
      action: '',
      description: '',
      priority: 0,
      sourceRange: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate',
  headers: {'content-type': 'application/json'},
  data: {ingressRules: [{action: '', description: '', priority: 0, sourceRange: ''}]}
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ingressRules":[{"action":"","description":"","priority":0,"sourceRange":""}]}'
};

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}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ingressRules": [\n    {\n      "action": "",\n      "description": "",\n      "priority": 0,\n      "sourceRange": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({ingressRules: [{action: '', description: '', priority: 0, sourceRange: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate',
  headers: {'content-type': 'application/json'},
  body: {ingressRules: [{action: '', description: '', priority: 0, sourceRange: ''}]},
  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}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate');

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

req.type('json');
req.send({
  ingressRules: [
    {
      action: '',
      description: '',
      priority: 0,
      sourceRange: ''
    }
  ]
});

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}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate',
  headers: {'content-type': 'application/json'},
  data: {ingressRules: [{action: '', description: '', priority: 0, sourceRange: ''}]}
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ingressRules":[{"action":"","description":"","priority":0,"sourceRange":""}]}'
};

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 = @{ @"ingressRules": @[ @{ @"action": @"", @"description": @"", @"priority": @0, @"sourceRange": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ingressRules' => [
        [
                'action' => '',
                'description' => '',
                'priority' => 0,
                'sourceRange' => ''
        ]
    ]
  ]),
  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}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate', [
  'body' => '{
  "ingressRules": [
    {
      "action": "",
      "description": "",
      "priority": 0,
      "sourceRange": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ingressRules' => [
    [
        'action' => '',
        'description' => '',
        'priority' => 0,
        'sourceRange' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'ingressRules' => [
    [
        'action' => '',
        'description' => '',
        'priority' => 0,
        'sourceRange' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ingressRules": [
    {
      "action": "",
      "description": "",
      "priority": 0,
      "sourceRange": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ingressRules": [
    {
      "action": "",
      "description": "",
      "priority": 0,
      "sourceRange": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate"

payload = { "ingressRules": [
        {
            "action": "",
            "description": "",
            "priority": 0,
            "sourceRange": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate"

payload <- "{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate') do |req|
  req.body = "{\n  \"ingressRules\": [\n    {\n      \"action\": \"\",\n      \"description\": \"\",\n      \"priority\": 0,\n      \"sourceRange\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate";

    let payload = json!({"ingressRules": (
            json!({
                "action": "",
                "description": "",
                "priority": 0,
                "sourceRange": ""
            })
        )});

    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}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate \
  --header 'content-type: application/json' \
  --data '{
  "ingressRules": [
    {
      "action": "",
      "description": "",
      "priority": 0,
      "sourceRange": ""
    }
  ]
}'

echo '{
  "ingressRules": [
    {
      "action": "",
      "description": "",
      "priority": 0,
      "sourceRange": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ingressRules": [\n    {\n      "action": "",\n      "description": "",\n      "priority": 0,\n      "sourceRange": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules:batchUpdate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["ingressRules": [
    [
      "action": "",
      "description": "",
      "priority": 0,
      "sourceRange": ""
    ]
  ]] as [String : Any]

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

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

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

dataTask.resume()

POST appengine.apps.firewall.ingressRules.create

{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules

QUERY PARAMS

appsId

BODY json

{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules");

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  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules" {:content-type :json
                                                                                      :form-params {:action ""
                                                                                                    :description ""
                                                                                                    :priority 0
                                                                                                    :sourceRange ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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}}/v1beta/apps/:appsId/firewall/ingressRules"),
    Content = new StringContent("{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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}}/v1beta/apps/:appsId/firewall/ingressRules");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules"

	payload := strings.NewReader("{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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/v1beta/apps/:appsId/firewall/ingressRules HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 77

{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules")
  .header("content-type", "application/json")
  .body("{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  action: '',
  description: '',
  priority: 0,
  sourceRange: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules',
  headers: {'content-type': 'application/json'},
  data: {action: '', description: '', priority: 0, sourceRange: ''}
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"action":"","description":"","priority":0,"sourceRange":""}'
};

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}}/v1beta/apps/:appsId/firewall/ingressRules',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "action": "",\n  "description": "",\n  "priority": 0,\n  "sourceRange": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules")
  .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/v1beta/apps/:appsId/firewall/ingressRules',
  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({action: '', description: '', priority: 0, sourceRange: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules',
  headers: {'content-type': 'application/json'},
  body: {action: '', description: '', priority: 0, sourceRange: ''},
  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}}/v1beta/apps/:appsId/firewall/ingressRules');

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

req.type('json');
req.send({
  action: '',
  description: '',
  priority: 0,
  sourceRange: ''
});

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}}/v1beta/apps/:appsId/firewall/ingressRules',
  headers: {'content-type': 'application/json'},
  data: {action: '', description: '', priority: 0, sourceRange: ''}
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"action":"","description":"","priority":0,"sourceRange":""}'
};

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 = @{ @"action": @"",
                              @"description": @"",
                              @"priority": @0,
                              @"sourceRange": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules"]
                                                       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}}/v1beta/apps/:appsId/firewall/ingressRules" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules",
  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([
    'action' => '',
    'description' => '',
    'priority' => 0,
    'sourceRange' => ''
  ]),
  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}}/v1beta/apps/:appsId/firewall/ingressRules', [
  'body' => '{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'action' => '',
  'description' => '',
  'priority' => 0,
  'sourceRange' => ''
]));

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

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

append(json_encode([
  'action' => '',
  'description' => '',
  'priority' => 0,
  'sourceRange' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules');
$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}}/v1beta/apps/:appsId/firewall/ingressRules' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}'

import http.client

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

payload = "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta/apps/:appsId/firewall/ingressRules", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules"

payload = {
    "action": "",
    "description": "",
    "priority": 0,
    "sourceRange": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules"

payload <- "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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}}/v1beta/apps/:appsId/firewall/ingressRules")

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  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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/v1beta/apps/:appsId/firewall/ingressRules') do |req|
  req.body = "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules";

    let payload = json!({
        "action": "",
        "description": "",
        "priority": 0,
        "sourceRange": ""
    });

    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}}/v1beta/apps/:appsId/firewall/ingressRules \
  --header 'content-type: application/json' \
  --data '{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}'

echo '{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}' |  \
  http POST {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "action": "",\n  "description": "",\n  "priority": 0,\n  "sourceRange": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules")! 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 appengine.apps.firewall.ingressRules.delete

{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId

QUERY PARAMS

appsId

ingressRulesId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"

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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"

	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/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"))
    .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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId';
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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId',
  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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');

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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId';
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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"]
                                                       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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId",
  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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")

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/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId";

    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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId

http DELETE {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")! 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 appengine.apps.firewall.ingressRules.get

{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId

QUERY PARAMS

appsId

ingressRulesId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"

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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"

	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/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"))
    .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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId';
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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId',
  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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');

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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId';
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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"]
                                                       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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId",
  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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")

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/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId";

    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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId

http GET {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")! 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 appengine.apps.firewall.ingressRules.list

{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules

QUERY PARAMS

appsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules"

	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/v1beta/apps/:appsId/firewall/ingressRules HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules"))
    .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}}/v1beta/apps/:appsId/firewall/ingressRules")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules")
  .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}}/v1beta/apps/:appsId/firewall/ingressRules');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules';
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}}/v1beta/apps/:appsId/firewall/ingressRules',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/firewall/ingressRules',
  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}}/v1beta/apps/:appsId/firewall/ingressRules'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules');

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}}/v1beta/apps/:appsId/firewall/ingressRules'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules';
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}}/v1beta/apps/:appsId/firewall/ingressRules"]
                                                       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}}/v1beta/apps/:appsId/firewall/ingressRules" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules",
  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}}/v1beta/apps/:appsId/firewall/ingressRules');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/firewall/ingressRules")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules")

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/v1beta/apps/:appsId/firewall/ingressRules') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules";

    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}}/v1beta/apps/:appsId/firewall/ingressRules

http GET {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules")! 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 appengine.apps.firewall.ingressRules.patch

{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId

QUERY PARAMS

appsId

ingressRulesId

BODY json

{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId");

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  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId" {:content-type :json
                                                                                                       :form-params {:action ""
                                                                                                                     :description ""
                                                                                                                     :priority 0
                                                                                                                     :sourceRange ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"),
    Content = new StringContent("{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"

	payload := strings.NewReader("{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 77

{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .header("content-type", "application/json")
  .body("{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  action: '',
  description: '',
  priority: 0,
  sourceRange: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId',
  headers: {'content-type': 'application/json'},
  data: {action: '', description: '', priority: 0, sourceRange: ''}
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"action":"","description":"","priority":0,"sourceRange":""}'
};

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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "action": "",\n  "description": "",\n  "priority": 0,\n  "sourceRange": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")
  .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/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId',
  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({action: '', description: '', priority: 0, sourceRange: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId',
  headers: {'content-type': 'application/json'},
  body: {action: '', description: '', priority: 0, sourceRange: ''},
  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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');

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

req.type('json');
req.send({
  action: '',
  description: '',
  priority: 0,
  sourceRange: ''
});

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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId',
  headers: {'content-type': 'application/json'},
  data: {action: '', description: '', priority: 0, sourceRange: ''}
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"action":"","description":"","priority":0,"sourceRange":""}'
};

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 = @{ @"action": @"",
                              @"description": @"",
                              @"priority": @0,
                              @"sourceRange": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"]
                                                       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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId",
  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([
    'action' => '',
    'description' => '',
    'priority' => 0,
    'sourceRange' => ''
  ]),
  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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId', [
  'body' => '{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'action' => '',
  'description' => '',
  'priority' => 0,
  'sourceRange' => ''
]));

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

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

append(json_encode([
  'action' => '',
  'description' => '',
  'priority' => 0,
  'sourceRange' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId');
$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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}'

import http.client

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

payload = "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"

payload = {
    "action": "",
    "description": "",
    "priority": 0,
    "sourceRange": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId"

payload <- "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")

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  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId') do |req|
  req.body = "{\n  \"action\": \"\",\n  \"description\": \"\",\n  \"priority\": 0,\n  \"sourceRange\": \"\"\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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId";

    let payload = json!({
        "action": "",
        "description": "",
        "priority": 0,
        "sourceRange": ""
    });

    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}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId \
  --header 'content-type: application/json' \
  --data '{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}'

echo '{
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
}' |  \
  http PATCH {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "action": "",\n  "description": "",\n  "priority": 0,\n  "sourceRange": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "action": "",
  "description": "",
  "priority": 0,
  "sourceRange": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/firewall/ingressRules/:ingressRulesId")! 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()

GET appengine.apps.get

{{baseUrl}}/v1beta/apps/:appsId

QUERY PARAMS

appsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId"

	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/v1beta/apps/:appsId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta/apps/:appsId'};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId';
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}}/v1beta/apps/:appsId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId');

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}}/v1beta/apps/:appsId'};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId';
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}}/v1beta/apps/:appsId"]
                                                       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}}/v1beta/apps/:appsId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId",
  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}}/v1beta/apps/:appsId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId")

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/v1beta/apps/:appsId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta/apps/:appsId

http GET {{baseUrl}}/v1beta/apps/:appsId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId")! 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 appengine.apps.locations.get

{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId

QUERY PARAMS

appsId

locationsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId"

	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/v1beta/apps/:appsId/locations/:locationsId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId';
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}}/v1beta/apps/:appsId/locations/:locationsId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId');

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}}/v1beta/apps/:appsId/locations/:locationsId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId';
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}}/v1beta/apps/:appsId/locations/:locationsId"]
                                                       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}}/v1beta/apps/:appsId/locations/:locationsId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId",
  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}}/v1beta/apps/:appsId/locations/:locationsId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/locations/:locationsId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId")

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/v1beta/apps/:appsId/locations/:locationsId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId";

    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}}/v1beta/apps/:appsId/locations/:locationsId

http GET {{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/locations/:locationsId")! 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 appengine.apps.locations.list

{{baseUrl}}/v1beta/apps/:appsId/locations

QUERY PARAMS

appsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/locations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/locations")

require "http/client"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/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/v1beta/apps/:appsId/locations HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/locations'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/locations")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/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}}/v1beta/apps/:appsId/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}}/v1beta/apps/:appsId/locations" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/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}}/v1beta/apps/:appsId/locations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/locations');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/locations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/locations' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/locations")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/locations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/locations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/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/v1beta/apps/:appsId/locations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/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}}/v1beta/apps/:appsId/locations

http GET {{baseUrl}}/v1beta/apps/:appsId/locations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/locations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/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()

GET appengine.apps.operations.get

{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId

QUERY PARAMS

appsId

operationsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId"

	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/v1beta/apps/:appsId/operations/:operationsId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId"))
    .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}}/v1beta/apps/:appsId/operations/:operationsId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId")
  .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}}/v1beta/apps/:appsId/operations/:operationsId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId';
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}}/v1beta/apps/:appsId/operations/:operationsId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/operations/:operationsId',
  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}}/v1beta/apps/:appsId/operations/:operationsId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId');

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}}/v1beta/apps/:appsId/operations/:operationsId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId';
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}}/v1beta/apps/:appsId/operations/:operationsId"]
                                                       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}}/v1beta/apps/:appsId/operations/:operationsId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId",
  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}}/v1beta/apps/:appsId/operations/:operationsId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/operations/:operationsId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId")

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/v1beta/apps/:appsId/operations/:operationsId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId";

    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}}/v1beta/apps/:appsId/operations/:operationsId

http GET {{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/operations/:operationsId")! 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 appengine.apps.operations.list

{{baseUrl}}/v1beta/apps/:appsId/operations

QUERY PARAMS

appsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/operations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/operations")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/operations"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/operations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/operations"

	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/v1beta/apps/:appsId/operations HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/operations"))
    .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}}/v1beta/apps/:appsId/operations")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/operations")
  .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}}/v1beta/apps/:appsId/operations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/operations'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/operations';
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}}/v1beta/apps/:appsId/operations',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/operations")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/operations');

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}}/v1beta/apps/:appsId/operations'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/operations';
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}}/v1beta/apps/:appsId/operations"]
                                                       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}}/v1beta/apps/:appsId/operations" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/operations",
  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}}/v1beta/apps/:appsId/operations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/operations');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/operations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/operations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/operations' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/operations")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/operations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/operations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/operations")

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/v1beta/apps/:appsId/operations') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta/apps/:appsId/operations

http GET {{baseUrl}}/v1beta/apps/:appsId/operations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/operations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/operations")! 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 appengine.apps.patch

{{baseUrl}}/v1beta/apps/:appsId

QUERY PARAMS

appsId

BODY json

{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId");

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  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1beta/apps/:appsId" {:content-type :json
                                                                 :form-params {:authDomain ""
                                                                               :codeBucket ""
                                                                               :databaseType ""
                                                                               :defaultBucket ""
                                                                               :defaultCookieExpiration ""
                                                                               :defaultHostname ""
                                                                               :dispatchRules [{:domain ""
                                                                                                :path ""
                                                                                                :service ""}]
                                                                               :featureSettings {:splitHealthChecks false
                                                                                                 :useContainerOptimizedOs false}
                                                                               :gcrDomain ""
                                                                               :iap {:enabled false
                                                                                     :oauth2ClientId ""
                                                                                     :oauth2ClientSecret ""
                                                                                     :oauth2ClientSecretSha256 ""}
                                                                               :id ""
                                                                               :locationId ""
                                                                               :name ""
                                                                               :serviceAccount ""
                                                                               :servingStatus ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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}}/v1beta/apps/:appsId"),
    Content = new StringContent("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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}}/v1beta/apps/:appsId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId"

	payload := strings.NewReader("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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/v1beta/apps/:appsId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 579

{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1beta/apps/:appsId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1beta/apps/:appsId")
  .header("content-type", "application/json")
  .body("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  authDomain: '',
  codeBucket: '',
  databaseType: '',
  defaultBucket: '',
  defaultCookieExpiration: '',
  defaultHostname: '',
  dispatchRules: [
    {
      domain: '',
      path: '',
      service: ''
    }
  ],
  featureSettings: {
    splitHealthChecks: false,
    useContainerOptimizedOs: false
  },
  gcrDomain: '',
  iap: {
    enabled: false,
    oauth2ClientId: '',
    oauth2ClientSecret: '',
    oauth2ClientSecretSha256: ''
  },
  id: '',
  locationId: '',
  name: '',
  serviceAccount: '',
  servingStatus: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId',
  headers: {'content-type': 'application/json'},
  data: {
    authDomain: '',
    codeBucket: '',
    databaseType: '',
    defaultBucket: '',
    defaultCookieExpiration: '',
    defaultHostname: '',
    dispatchRules: [{domain: '', path: '', service: ''}],
    featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
    gcrDomain: '',
    iap: {
      enabled: false,
      oauth2ClientId: '',
      oauth2ClientSecret: '',
      oauth2ClientSecretSha256: ''
    },
    id: '',
    locationId: '',
    name: '',
    serviceAccount: '',
    servingStatus: ''
  }
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"authDomain":"","codeBucket":"","databaseType":"","defaultBucket":"","defaultCookieExpiration":"","defaultHostname":"","dispatchRules":[{"domain":"","path":"","service":""}],"featureSettings":{"splitHealthChecks":false,"useContainerOptimizedOs":false},"gcrDomain":"","iap":{"enabled":false,"oauth2ClientId":"","oauth2ClientSecret":"","oauth2ClientSecretSha256":""},"id":"","locationId":"","name":"","serviceAccount":"","servingStatus":""}'
};

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}}/v1beta/apps/:appsId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authDomain": "",\n  "codeBucket": "",\n  "databaseType": "",\n  "defaultBucket": "",\n  "defaultCookieExpiration": "",\n  "defaultHostname": "",\n  "dispatchRules": [\n    {\n      "domain": "",\n      "path": "",\n      "service": ""\n    }\n  ],\n  "featureSettings": {\n    "splitHealthChecks": false,\n    "useContainerOptimizedOs": false\n  },\n  "gcrDomain": "",\n  "iap": {\n    "enabled": false,\n    "oauth2ClientId": "",\n    "oauth2ClientSecret": "",\n    "oauth2ClientSecretSha256": ""\n  },\n  "id": "",\n  "locationId": "",\n  "name": "",\n  "serviceAccount": "",\n  "servingStatus": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId")
  .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/v1beta/apps/:appsId',
  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({
  authDomain: '',
  codeBucket: '',
  databaseType: '',
  defaultBucket: '',
  defaultCookieExpiration: '',
  defaultHostname: '',
  dispatchRules: [{domain: '', path: '', service: ''}],
  featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
  gcrDomain: '',
  iap: {
    enabled: false,
    oauth2ClientId: '',
    oauth2ClientSecret: '',
    oauth2ClientSecretSha256: ''
  },
  id: '',
  locationId: '',
  name: '',
  serviceAccount: '',
  servingStatus: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId',
  headers: {'content-type': 'application/json'},
  body: {
    authDomain: '',
    codeBucket: '',
    databaseType: '',
    defaultBucket: '',
    defaultCookieExpiration: '',
    defaultHostname: '',
    dispatchRules: [{domain: '', path: '', service: ''}],
    featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
    gcrDomain: '',
    iap: {
      enabled: false,
      oauth2ClientId: '',
      oauth2ClientSecret: '',
      oauth2ClientSecretSha256: ''
    },
    id: '',
    locationId: '',
    name: '',
    serviceAccount: '',
    servingStatus: ''
  },
  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}}/v1beta/apps/:appsId');

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

req.type('json');
req.send({
  authDomain: '',
  codeBucket: '',
  databaseType: '',
  defaultBucket: '',
  defaultCookieExpiration: '',
  defaultHostname: '',
  dispatchRules: [
    {
      domain: '',
      path: '',
      service: ''
    }
  ],
  featureSettings: {
    splitHealthChecks: false,
    useContainerOptimizedOs: false
  },
  gcrDomain: '',
  iap: {
    enabled: false,
    oauth2ClientId: '',
    oauth2ClientSecret: '',
    oauth2ClientSecretSha256: ''
  },
  id: '',
  locationId: '',
  name: '',
  serviceAccount: '',
  servingStatus: ''
});

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}}/v1beta/apps/:appsId',
  headers: {'content-type': 'application/json'},
  data: {
    authDomain: '',
    codeBucket: '',
    databaseType: '',
    defaultBucket: '',
    defaultCookieExpiration: '',
    defaultHostname: '',
    dispatchRules: [{domain: '', path: '', service: ''}],
    featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
    gcrDomain: '',
    iap: {
      enabled: false,
      oauth2ClientId: '',
      oauth2ClientSecret: '',
      oauth2ClientSecretSha256: ''
    },
    id: '',
    locationId: '',
    name: '',
    serviceAccount: '',
    servingStatus: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"authDomain":"","codeBucket":"","databaseType":"","defaultBucket":"","defaultCookieExpiration":"","defaultHostname":"","dispatchRules":[{"domain":"","path":"","service":""}],"featureSettings":{"splitHealthChecks":false,"useContainerOptimizedOs":false},"gcrDomain":"","iap":{"enabled":false,"oauth2ClientId":"","oauth2ClientSecret":"","oauth2ClientSecretSha256":""},"id":"","locationId":"","name":"","serviceAccount":"","servingStatus":""}'
};

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 = @{ @"authDomain": @"",
                              @"codeBucket": @"",
                              @"databaseType": @"",
                              @"defaultBucket": @"",
                              @"defaultCookieExpiration": @"",
                              @"defaultHostname": @"",
                              @"dispatchRules": @[ @{ @"domain": @"", @"path": @"", @"service": @"" } ],
                              @"featureSettings": @{ @"splitHealthChecks": @NO, @"useContainerOptimizedOs": @NO },
                              @"gcrDomain": @"",
                              @"iap": @{ @"enabled": @NO, @"oauth2ClientId": @"", @"oauth2ClientSecret": @"", @"oauth2ClientSecretSha256": @"" },
                              @"id": @"",
                              @"locationId": @"",
                              @"name": @"",
                              @"serviceAccount": @"",
                              @"servingStatus": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId"]
                                                       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}}/v1beta/apps/:appsId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId",
  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([
    'authDomain' => '',
    'codeBucket' => '',
    'databaseType' => '',
    'defaultBucket' => '',
    'defaultCookieExpiration' => '',
    'defaultHostname' => '',
    'dispatchRules' => [
        [
                'domain' => '',
                'path' => '',
                'service' => ''
        ]
    ],
    'featureSettings' => [
        'splitHealthChecks' => null,
        'useContainerOptimizedOs' => null
    ],
    'gcrDomain' => '',
    'iap' => [
        'enabled' => null,
        'oauth2ClientId' => '',
        'oauth2ClientSecret' => '',
        'oauth2ClientSecretSha256' => ''
    ],
    'id' => '',
    'locationId' => '',
    'name' => '',
    'serviceAccount' => '',
    'servingStatus' => ''
  ]),
  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}}/v1beta/apps/:appsId', [
  'body' => '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authDomain' => '',
  'codeBucket' => '',
  'databaseType' => '',
  'defaultBucket' => '',
  'defaultCookieExpiration' => '',
  'defaultHostname' => '',
  'dispatchRules' => [
    [
        'domain' => '',
        'path' => '',
        'service' => ''
    ]
  ],
  'featureSettings' => [
    'splitHealthChecks' => null,
    'useContainerOptimizedOs' => null
  ],
  'gcrDomain' => '',
  'iap' => [
    'enabled' => null,
    'oauth2ClientId' => '',
    'oauth2ClientSecret' => '',
    'oauth2ClientSecretSha256' => ''
  ],
  'id' => '',
  'locationId' => '',
  'name' => '',
  'serviceAccount' => '',
  'servingStatus' => ''
]));

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

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

append(json_encode([
  'authDomain' => '',
  'codeBucket' => '',
  'databaseType' => '',
  'defaultBucket' => '',
  'defaultCookieExpiration' => '',
  'defaultHostname' => '',
  'dispatchRules' => [
    [
        'domain' => '',
        'path' => '',
        'service' => ''
    ]
  ],
  'featureSettings' => [
    'splitHealthChecks' => null,
    'useContainerOptimizedOs' => null
  ],
  'gcrDomain' => '',
  'iap' => [
    'enabled' => null,
    'oauth2ClientId' => '',
    'oauth2ClientSecret' => '',
    'oauth2ClientSecretSha256' => ''
  ],
  'id' => '',
  'locationId' => '',
  'name' => '',
  'serviceAccount' => '',
  'servingStatus' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId');
$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}}/v1beta/apps/:appsId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}'

import http.client

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

payload = "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/v1beta/apps/:appsId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId"

payload = {
    "authDomain": "",
    "codeBucket": "",
    "databaseType": "",
    "defaultBucket": "",
    "defaultCookieExpiration": "",
    "defaultHostname": "",
    "dispatchRules": [
        {
            "domain": "",
            "path": "",
            "service": ""
        }
    ],
    "featureSettings": {
        "splitHealthChecks": False,
        "useContainerOptimizedOs": False
    },
    "gcrDomain": "",
    "iap": {
        "enabled": False,
        "oauth2ClientId": "",
        "oauth2ClientSecret": "",
        "oauth2ClientSecretSha256": ""
    },
    "id": "",
    "locationId": "",
    "name": "",
    "serviceAccount": "",
    "servingStatus": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId"

payload <- "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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}}/v1beta/apps/:appsId")

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  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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/v1beta/apps/:appsId') do |req|
  req.body = "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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}}/v1beta/apps/:appsId";

    let payload = json!({
        "authDomain": "",
        "codeBucket": "",
        "databaseType": "",
        "defaultBucket": "",
        "defaultCookieExpiration": "",
        "defaultHostname": "",
        "dispatchRules": (
            json!({
                "domain": "",
                "path": "",
                "service": ""
            })
        ),
        "featureSettings": json!({
            "splitHealthChecks": false,
            "useContainerOptimizedOs": false
        }),
        "gcrDomain": "",
        "iap": json!({
            "enabled": false,
            "oauth2ClientId": "",
            "oauth2ClientSecret": "",
            "oauth2ClientSecretSha256": ""
        }),
        "id": "",
        "locationId": "",
        "name": "",
        "serviceAccount": "",
        "servingStatus": ""
    });

    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}}/v1beta/apps/:appsId \
  --header 'content-type: application/json' \
  --data '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}'

echo '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}' |  \
  http PATCH {{baseUrl}}/v1beta/apps/:appsId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "authDomain": "",\n  "codeBucket": "",\n  "databaseType": "",\n  "defaultBucket": "",\n  "defaultCookieExpiration": "",\n  "defaultHostname": "",\n  "dispatchRules": [\n    {\n      "domain": "",\n      "path": "",\n      "service": ""\n    }\n  ],\n  "featureSettings": {\n    "splitHealthChecks": false,\n    "useContainerOptimizedOs": false\n  },\n  "gcrDomain": "",\n  "iap": {\n    "enabled": false,\n    "oauth2ClientId": "",\n    "oauth2ClientSecret": "",\n    "oauth2ClientSecretSha256": ""\n  },\n  "id": "",\n  "locationId": "",\n  "name": "",\n  "serviceAccount": "",\n  "servingStatus": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    [
      "domain": "",
      "path": "",
      "service": ""
    ]
  ],
  "featureSettings": [
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  ],
  "gcrDomain": "",
  "iap": [
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  ],
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId")! 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 appengine.apps.repair

{{baseUrl}}/v1beta/apps/:appsId:repair

QUERY PARAMS

appsId

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId:repair");

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}}/v1beta/apps/:appsId:repair" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId:repair"
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}}/v1beta/apps/:appsId:repair"),
    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}}/v1beta/apps/:appsId:repair");
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}}/v1beta/apps/:appsId:repair"

	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/v1beta/apps/:appsId:repair HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId:repair"))
    .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}}/v1beta/apps/:appsId:repair")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/apps/:appsId:repair")
  .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}}/v1beta/apps/:appsId:repair');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId:repair',
  headers: {'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId:repair';
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}}/v1beta/apps/:appsId:repair',
  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}}/v1beta/apps/:appsId:repair")
  .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/v1beta/apps/:appsId:repair',
  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}}/v1beta/apps/:appsId:repair',
  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}}/v1beta/apps/:appsId:repair');

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}}/v1beta/apps/:appsId:repair',
  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}}/v1beta/apps/:appsId:repair';
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}}/v1beta/apps/:appsId:repair"]
                                                       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}}/v1beta/apps/:appsId:repair" 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}}/v1beta/apps/:appsId:repair",
  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}}/v1beta/apps/:appsId:repair', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId:repair');
$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}}/v1beta/apps/:appsId:repair');
$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}}/v1beta/apps/:appsId:repair' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId:repair' -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/v1beta/apps/:appsId:repair", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId:repair"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId:repair"

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}}/v1beta/apps/:appsId:repair")

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/v1beta/apps/:appsId:repair') 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}}/v1beta/apps/:appsId:repair";

    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}}/v1beta/apps/:appsId:repair \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/v1beta/apps/:appsId:repair \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId:repair

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}}/v1beta/apps/:appsId:repair")! 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 appengine.apps.services.delete

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId

QUERY PARAMS

appsId

servicesId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"

	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/v1beta/apps/:appsId/services/:servicesId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"))
    .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}}/v1beta/apps/:appsId/services/:servicesId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")
  .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}}/v1beta/apps/:appsId/services/:servicesId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId';
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}}/v1beta/apps/:appsId/services/:servicesId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/services/:servicesId',
  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}}/v1beta/apps/:appsId/services/:servicesId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId');

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}}/v1beta/apps/:appsId/services/:servicesId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId';
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}}/v1beta/apps/:appsId/services/:servicesId"]
                                                       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}}/v1beta/apps/:appsId/services/:servicesId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId",
  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}}/v1beta/apps/:appsId/services/:servicesId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1beta/apps/:appsId/services/:servicesId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")

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/v1beta/apps/:appsId/services/:servicesId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId";

    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}}/v1beta/apps/:appsId/services/:servicesId

http DELETE {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")! 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 appengine.apps.services.get

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId

QUERY PARAMS

appsId

servicesId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"

	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/v1beta/apps/:appsId/services/:servicesId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"))
    .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}}/v1beta/apps/:appsId/services/:servicesId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")
  .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}}/v1beta/apps/:appsId/services/:servicesId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId';
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}}/v1beta/apps/:appsId/services/:servicesId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/services/:servicesId',
  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}}/v1beta/apps/:appsId/services/:servicesId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId');

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}}/v1beta/apps/:appsId/services/:servicesId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId';
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}}/v1beta/apps/:appsId/services/:servicesId"]
                                                       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}}/v1beta/apps/:appsId/services/:servicesId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId",
  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}}/v1beta/apps/:appsId/services/:servicesId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/services/:servicesId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")

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/v1beta/apps/:appsId/services/:servicesId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId";

    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}}/v1beta/apps/:appsId/services/:servicesId

http GET {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")! 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 appengine.apps.services.list

{{baseUrl}}/v1beta/apps/:appsId/services

QUERY PARAMS

appsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/services")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services"

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/services");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services"

	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/v1beta/apps/:appsId/services HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services"))
    .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}}/v1beta/apps/:appsId/services")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/services")
  .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}}/v1beta/apps/:appsId/services');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta/apps/:appsId/services'};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services';
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}}/v1beta/apps/:appsId/services',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/services');

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}}/v1beta/apps/:appsId/services'};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services';
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}}/v1beta/apps/:appsId/services"]
                                                       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}}/v1beta/apps/:appsId/services" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services",
  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}}/v1beta/apps/:appsId/services');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/services' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/services")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/services")

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/v1beta/apps/:appsId/services') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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}}/v1beta/apps/:appsId/services

http GET {{baseUrl}}/v1beta/apps/:appsId/services

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services")! 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 appengine.apps.services.patch

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId

QUERY PARAMS

appsId

servicesId

BODY json

{
  "id": "",
  "labels": {},
  "name": "",
  "networkSettings": {
    "ingressTrafficAllowed": ""
  },
  "split": {
    "allocations": {},
    "shardBy": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId");

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  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId" {:content-type :json
                                                                                      :form-params {:id ""
                                                                                                    :labels {}
                                                                                                    :name ""
                                                                                                    :networkSettings {:ingressTrafficAllowed ""}
                                                                                                    :split {:allocations {}
                                                                                                            :shardBy ""}}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\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}}/v1beta/apps/:appsId/services/:servicesId"),
    Content = new StringContent("{\n  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\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}}/v1beta/apps/:appsId/services/:servicesId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\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/v1beta/apps/:appsId/services/:servicesId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 163

{
  "id": "",
  "labels": {},
  "name": "",
  "networkSettings": {
    "ingressTrafficAllowed": ""
  },
  "split": {
    "allocations": {},
    "shardBy": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\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  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  labels: {},
  name: '',
  networkSettings: {
    ingressTrafficAllowed: ''
  },
  split: {
    allocations: {},
    shardBy: ''
  }
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    labels: {},
    name: '',
    networkSettings: {ingressTrafficAllowed: ''},
    split: {allocations: {}, shardBy: ''}
  }
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","labels":{},"name":"","networkSettings":{"ingressTrafficAllowed":""},"split":{"allocations":{},"shardBy":""}}'
};

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}}/v1beta/apps/:appsId/services/:servicesId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "labels": {},\n  "name": "",\n  "networkSettings": {\n    "ingressTrafficAllowed": ""\n  },\n  "split": {\n    "allocations": {},\n    "shardBy": ""\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  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")
  .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/v1beta/apps/:appsId/services/:servicesId',
  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({
  id: '',
  labels: {},
  name: '',
  networkSettings: {ingressTrafficAllowed: ''},
  split: {allocations: {}, shardBy: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId',
  headers: {'content-type': 'application/json'},
  body: {
    id: '',
    labels: {},
    name: '',
    networkSettings: {ingressTrafficAllowed: ''},
    split: {allocations: {}, shardBy: ''}
  },
  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}}/v1beta/apps/:appsId/services/:servicesId');

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

req.type('json');
req.send({
  id: '',
  labels: {},
  name: '',
  networkSettings: {
    ingressTrafficAllowed: ''
  },
  split: {
    allocations: {},
    shardBy: ''
  }
});

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}}/v1beta/apps/:appsId/services/:servicesId',
  headers: {'content-type': 'application/json'},
  data: {
    id: '',
    labels: {},
    name: '',
    networkSettings: {ingressTrafficAllowed: ''},
    split: {allocations: {}, shardBy: ''}
  }
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"id":"","labels":{},"name":"","networkSettings":{"ingressTrafficAllowed":""},"split":{"allocations":{},"shardBy":""}}'
};

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 = @{ @"id": @"",
                              @"labels": @{  },
                              @"name": @"",
                              @"networkSettings": @{ @"ingressTrafficAllowed": @"" },
                              @"split": @{ @"allocations": @{  }, @"shardBy": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"]
                                                       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}}/v1beta/apps/:appsId/services/:servicesId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId",
  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([
    'id' => '',
    'labels' => [
        
    ],
    'name' => '',
    'networkSettings' => [
        'ingressTrafficAllowed' => ''
    ],
    'split' => [
        'allocations' => [
                
        ],
        'shardBy' => ''
    ]
  ]),
  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}}/v1beta/apps/:appsId/services/:servicesId', [
  'body' => '{
  "id": "",
  "labels": {},
  "name": "",
  "networkSettings": {
    "ingressTrafficAllowed": ""
  },
  "split": {
    "allocations": {},
    "shardBy": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'labels' => [
    
  ],
  'name' => '',
  'networkSettings' => [
    'ingressTrafficAllowed' => ''
  ],
  'split' => [
    'allocations' => [
        
    ],
    'shardBy' => ''
  ]
]));

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

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

append(json_encode([
  'id' => '',
  'labels' => [
    
  ],
  'name' => '',
  'networkSettings' => [
    'ingressTrafficAllowed' => ''
  ],
  'split' => [
    'allocations' => [
        
    ],
    'shardBy' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId');
$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}}/v1beta/apps/:appsId/services/:servicesId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "labels": {},
  "name": "",
  "networkSettings": {
    "ingressTrafficAllowed": ""
  },
  "split": {
    "allocations": {},
    "shardBy": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "labels": {},
  "name": "",
  "networkSettings": {
    "ingressTrafficAllowed": ""
  },
  "split": {
    "allocations": {},
    "shardBy": ""
  }
}'

import http.client

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

payload = "{\n  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\n}"

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

conn.request("PATCH", "/baseUrl/v1beta/apps/:appsId/services/:servicesId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"

payload = {
    "id": "",
    "labels": {},
    "name": "",
    "networkSettings": { "ingressTrafficAllowed": "" },
    "split": {
        "allocations": {},
        "shardBy": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId"

payload <- "{\n  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\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}}/v1beta/apps/:appsId/services/:servicesId")

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  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\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.patch('/baseUrl/v1beta/apps/:appsId/services/:servicesId') do |req|
  req.body = "{\n  \"id\": \"\",\n  \"labels\": {},\n  \"name\": \"\",\n  \"networkSettings\": {\n    \"ingressTrafficAllowed\": \"\"\n  },\n  \"split\": {\n    \"allocations\": {},\n    \"shardBy\": \"\"\n  }\n}"
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId";

    let payload = json!({
        "id": "",
        "labels": json!({}),
        "name": "",
        "networkSettings": json!({"ingressTrafficAllowed": ""}),
        "split": json!({
            "allocations": json!({}),
            "shardBy": ""
        })
    });

    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}}/v1beta/apps/:appsId/services/:servicesId \
  --header 'content-type: application/json' \
  --data '{
  "id": "",
  "labels": {},
  "name": "",
  "networkSettings": {
    "ingressTrafficAllowed": ""
  },
  "split": {
    "allocations": {},
    "shardBy": ""
  }
}'

echo '{
  "id": "",
  "labels": {},
  "name": "",
  "networkSettings": {
    "ingressTrafficAllowed": ""
  },
  "split": {
    "allocations": {},
    "shardBy": ""
  }
}' |  \
  http PATCH {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "labels": {},\n  "name": "",\n  "networkSettings": {\n    "ingressTrafficAllowed": ""\n  },\n  "split": {\n    "allocations": {},\n    "shardBy": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": "",
  "labels": [],
  "name": "",
  "networkSettings": ["ingressTrafficAllowed": ""],
  "split": [
    "allocations": [],
    "shardBy": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId")! 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 appengine.apps.services.versions.create

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions

QUERY PARAMS

appsId

servicesId

BODY json

{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions");

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  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions" {:content-type :json
                                                                                              :form-params {:apiConfig {:authFailAction ""
                                                                                                                        :login ""
                                                                                                                        :script ""
                                                                                                                        :securityLevel ""
                                                                                                                        :url ""}
                                                                                                            :appEngineApis false
                                                                                                            :automaticScaling {:coolDownPeriod ""
                                                                                                                               :cpuUtilization {:aggregationWindowLength ""
                                                                                                                                                :targetUtilization ""}
                                                                                                                               :customMetrics [{:filter ""
                                                                                                                                                :metricName ""
                                                                                                                                                :singleInstanceAssignment ""
                                                                                                                                                :targetType ""
                                                                                                                                                :targetUtilization ""}]
                                                                                                                               :diskUtilization {:targetReadBytesPerSecond 0
                                                                                                                                                 :targetReadOpsPerSecond 0
                                                                                                                                                 :targetWriteBytesPerSecond 0
                                                                                                                                                 :targetWriteOpsPerSecond 0}
                                                                                                                               :maxConcurrentRequests 0
                                                                                                                               :maxIdleInstances 0
                                                                                                                               :maxPendingLatency ""
                                                                                                                               :maxTotalInstances 0
                                                                                                                               :minIdleInstances 0
                                                                                                                               :minPendingLatency ""
                                                                                                                               :minTotalInstances 0
                                                                                                                               :networkUtilization {:targetReceivedBytesPerSecond 0
                                                                                                                                                    :targetReceivedPacketsPerSecond 0
                                                                                                                                                    :targetSentBytesPerSecond 0
                                                                                                                                                    :targetSentPacketsPerSecond 0}
                                                                                                                               :requestUtilization {:targetConcurrentRequests 0
                                                                                                                                                    :targetRequestCountPerSecond 0}
                                                                                                                               :standardSchedulerSettings {:maxInstances 0
                                                                                                                                                           :minInstances 0
                                                                                                                                                           :targetCpuUtilization ""
                                                                                                                                                           :targetThroughputUtilization ""}}
                                                                                                            :basicScaling {:idleTimeout ""
                                                                                                                           :maxInstances 0}
                                                                                                            :betaSettings {}
                                                                                                            :buildEnvVariables {}
                                                                                                            :createTime ""
                                                                                                            :createdBy ""
                                                                                                            :defaultExpiration ""
                                                                                                            :deployment {:build {:cloudBuildId ""}
                                                                                                                         :cloudBuildOptions {:appYamlPath ""
                                                                                                                                             :cloudBuildTimeout ""}
                                                                                                                         :container {:image ""}
                                                                                                                         :files {}
                                                                                                                         :zip {:filesCount 0
                                                                                                                               :sourceUrl ""}}
                                                                                                            :diskUsageBytes ""
                                                                                                            :endpointsApiService {:configId ""
                                                                                                                                  :disableTraceSampling false
                                                                                                                                  :name ""
                                                                                                                                  :rolloutStrategy ""}
                                                                                                            :entrypoint {:shell ""}
                                                                                                            :env ""
                                                                                                            :envVariables {}
                                                                                                            :errorHandlers [{:errorCode ""
                                                                                                                             :mimeType ""
                                                                                                                             :staticFile ""}]
                                                                                                            :flexibleRuntimeSettings {:operatingSystem ""
                                                                                                                                      :runtimeVersion ""}
                                                                                                            :handlers [{:apiEndpoint {:scriptPath ""}
                                                                                                                        :authFailAction ""
                                                                                                                        :login ""
                                                                                                                        :redirectHttpResponseCode ""
                                                                                                                        :script {:scriptPath ""}
                                                                                                                        :securityLevel ""
                                                                                                                        :staticFiles {:applicationReadable false
                                                                                                                                      :expiration ""
                                                                                                                                      :httpHeaders {}
                                                                                                                                      :mimeType ""
                                                                                                                                      :path ""
                                                                                                                                      :requireMatchingFile false
                                                                                                                                      :uploadPathRegex ""}
                                                                                                                        :urlRegex ""}]
                                                                                                            :healthCheck {:checkInterval ""
                                                                                                                          :disableHealthCheck false
                                                                                                                          :healthyThreshold 0
                                                                                                                          :host ""
                                                                                                                          :restartThreshold 0
                                                                                                                          :timeout ""
                                                                                                                          :unhealthyThreshold 0}
                                                                                                            :id ""
                                                                                                            :inboundServices []
                                                                                                            :instanceClass ""
                                                                                                            :libraries [{:name ""
                                                                                                                         :version ""}]
                                                                                                            :livenessCheck {:checkInterval ""
                                                                                                                            :failureThreshold 0
                                                                                                                            :host ""
                                                                                                                            :initialDelay ""
                                                                                                                            :path ""
                                                                                                                            :successThreshold 0
                                                                                                                            :timeout ""}
                                                                                                            :manualScaling {:instances 0}
                                                                                                            :name ""
                                                                                                            :network {:forwardedPorts []
                                                                                                                      :instanceIpMode ""
                                                                                                                      :instanceTag ""
                                                                                                                      :name ""
                                                                                                                      :sessionAffinity false
                                                                                                                      :subnetworkName ""}
                                                                                                            :nobuildFilesRegex ""
                                                                                                            :readinessCheck {:appStartTimeout ""
                                                                                                                             :checkInterval ""
                                                                                                                             :failureThreshold 0
                                                                                                                             :host ""
                                                                                                                             :path ""
                                                                                                                             :successThreshold 0
                                                                                                                             :timeout ""}
                                                                                                            :resources {:cpu ""
                                                                                                                        :diskGb ""
                                                                                                                        :kmsKeyReference ""
                                                                                                                        :memoryGb ""
                                                                                                                        :volumes [{:name ""
                                                                                                                                   :sizeGb ""
                                                                                                                                   :volumeType ""}]}
                                                                                                            :runtime ""
                                                                                                            :runtimeApiVersion ""
                                                                                                            :runtimeChannel ""
                                                                                                            :runtimeMainExecutablePath ""
                                                                                                            :serviceAccount ""
                                                                                                            :servingStatus ""
                                                                                                            :threadsafe false
                                                                                                            :versionUrl ""
                                                                                                            :vm false
                                                                                                            :vpcAccessConnector {:egressSetting ""
                                                                                                                                 :name ""}
                                                                                                            :zones []}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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}}/v1beta/apps/:appsId/services/:servicesId/versions"),
    Content = new StringContent("{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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}}/v1beta/apps/:appsId/services/:servicesId/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions"

	payload := strings.NewReader("{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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/v1beta/apps/:appsId/services/:servicesId/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 4189

{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")
  .header("content-type", "application/json")
  .body("{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}")
  .asString();

const data = JSON.stringify({
  apiConfig: {
    authFailAction: '',
    login: '',
    script: '',
    securityLevel: '',
    url: ''
  },
  appEngineApis: false,
  automaticScaling: {
    coolDownPeriod: '',
    cpuUtilization: {
      aggregationWindowLength: '',
      targetUtilization: ''
    },
    customMetrics: [
      {
        filter: '',
        metricName: '',
        singleInstanceAssignment: '',
        targetType: '',
        targetUtilization: ''
      }
    ],
    diskUtilization: {
      targetReadBytesPerSecond: 0,
      targetReadOpsPerSecond: 0,
      targetWriteBytesPerSecond: 0,
      targetWriteOpsPerSecond: 0
    },
    maxConcurrentRequests: 0,
    maxIdleInstances: 0,
    maxPendingLatency: '',
    maxTotalInstances: 0,
    minIdleInstances: 0,
    minPendingLatency: '',
    minTotalInstances: 0,
    networkUtilization: {
      targetReceivedBytesPerSecond: 0,
      targetReceivedPacketsPerSecond: 0,
      targetSentBytesPerSecond: 0,
      targetSentPacketsPerSecond: 0
    },
    requestUtilization: {
      targetConcurrentRequests: 0,
      targetRequestCountPerSecond: 0
    },
    standardSchedulerSettings: {
      maxInstances: 0,
      minInstances: 0,
      targetCpuUtilization: '',
      targetThroughputUtilization: ''
    }
  },
  basicScaling: {
    idleTimeout: '',
    maxInstances: 0
  },
  betaSettings: {},
  buildEnvVariables: {},
  createTime: '',
  createdBy: '',
  defaultExpiration: '',
  deployment: {
    build: {
      cloudBuildId: ''
    },
    cloudBuildOptions: {
      appYamlPath: '',
      cloudBuildTimeout: ''
    },
    container: {
      image: ''
    },
    files: {},
    zip: {
      filesCount: 0,
      sourceUrl: ''
    }
  },
  diskUsageBytes: '',
  endpointsApiService: {
    configId: '',
    disableTraceSampling: false,
    name: '',
    rolloutStrategy: ''
  },
  entrypoint: {
    shell: ''
  },
  env: '',
  envVariables: {},
  errorHandlers: [
    {
      errorCode: '',
      mimeType: '',
      staticFile: ''
    }
  ],
  flexibleRuntimeSettings: {
    operatingSystem: '',
    runtimeVersion: ''
  },
  handlers: [
    {
      apiEndpoint: {
        scriptPath: ''
      },
      authFailAction: '',
      login: '',
      redirectHttpResponseCode: '',
      script: {
        scriptPath: ''
      },
      securityLevel: '',
      staticFiles: {
        applicationReadable: false,
        expiration: '',
        httpHeaders: {},
        mimeType: '',
        path: '',
        requireMatchingFile: false,
        uploadPathRegex: ''
      },
      urlRegex: ''
    }
  ],
  healthCheck: {
    checkInterval: '',
    disableHealthCheck: false,
    healthyThreshold: 0,
    host: '',
    restartThreshold: 0,
    timeout: '',
    unhealthyThreshold: 0
  },
  id: '',
  inboundServices: [],
  instanceClass: '',
  libraries: [
    {
      name: '',
      version: ''
    }
  ],
  livenessCheck: {
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    initialDelay: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  manualScaling: {
    instances: 0
  },
  name: '',
  network: {
    forwardedPorts: [],
    instanceIpMode: '',
    instanceTag: '',
    name: '',
    sessionAffinity: false,
    subnetworkName: ''
  },
  nobuildFilesRegex: '',
  readinessCheck: {
    appStartTimeout: '',
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  resources: {
    cpu: '',
    diskGb: '',
    kmsKeyReference: '',
    memoryGb: '',
    volumes: [
      {
        name: '',
        sizeGb: '',
        volumeType: ''
      }
    ]
  },
  runtime: '',
  runtimeApiVersion: '',
  runtimeChannel: '',
  runtimeMainExecutablePath: '',
  serviceAccount: '',
  servingStatus: '',
  threadsafe: false,
  versionUrl: '',
  vm: false,
  vpcAccessConnector: {
    egressSetting: '',
    name: ''
  },
  zones: []
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions',
  headers: {'content-type': 'application/json'},
  data: {
    apiConfig: {authFailAction: '', login: '', script: '', securityLevel: '', url: ''},
    appEngineApis: false,
    automaticScaling: {
      coolDownPeriod: '',
      cpuUtilization: {aggregationWindowLength: '', targetUtilization: ''},
      customMetrics: [
        {
          filter: '',
          metricName: '',
          singleInstanceAssignment: '',
          targetType: '',
          targetUtilization: ''
        }
      ],
      diskUtilization: {
        targetReadBytesPerSecond: 0,
        targetReadOpsPerSecond: 0,
        targetWriteBytesPerSecond: 0,
        targetWriteOpsPerSecond: 0
      },
      maxConcurrentRequests: 0,
      maxIdleInstances: 0,
      maxPendingLatency: '',
      maxTotalInstances: 0,
      minIdleInstances: 0,
      minPendingLatency: '',
      minTotalInstances: 0,
      networkUtilization: {
        targetReceivedBytesPerSecond: 0,
        targetReceivedPacketsPerSecond: 0,
        targetSentBytesPerSecond: 0,
        targetSentPacketsPerSecond: 0
      },
      requestUtilization: {targetConcurrentRequests: 0, targetRequestCountPerSecond: 0},
      standardSchedulerSettings: {
        maxInstances: 0,
        minInstances: 0,
        targetCpuUtilization: '',
        targetThroughputUtilization: ''
      }
    },
    basicScaling: {idleTimeout: '', maxInstances: 0},
    betaSettings: {},
    buildEnvVariables: {},
    createTime: '',
    createdBy: '',
    defaultExpiration: '',
    deployment: {
      build: {cloudBuildId: ''},
      cloudBuildOptions: {appYamlPath: '', cloudBuildTimeout: ''},
      container: {image: ''},
      files: {},
      zip: {filesCount: 0, sourceUrl: ''}
    },
    diskUsageBytes: '',
    endpointsApiService: {configId: '', disableTraceSampling: false, name: '', rolloutStrategy: ''},
    entrypoint: {shell: ''},
    env: '',
    envVariables: {},
    errorHandlers: [{errorCode: '', mimeType: '', staticFile: ''}],
    flexibleRuntimeSettings: {operatingSystem: '', runtimeVersion: ''},
    handlers: [
      {
        apiEndpoint: {scriptPath: ''},
        authFailAction: '',
        login: '',
        redirectHttpResponseCode: '',
        script: {scriptPath: ''},
        securityLevel: '',
        staticFiles: {
          applicationReadable: false,
          expiration: '',
          httpHeaders: {},
          mimeType: '',
          path: '',
          requireMatchingFile: false,
          uploadPathRegex: ''
        },
        urlRegex: ''
      }
    ],
    healthCheck: {
      checkInterval: '',
      disableHealthCheck: false,
      healthyThreshold: 0,
      host: '',
      restartThreshold: 0,
      timeout: '',
      unhealthyThreshold: 0
    },
    id: '',
    inboundServices: [],
    instanceClass: '',
    libraries: [{name: '', version: ''}],
    livenessCheck: {
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      initialDelay: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    manualScaling: {instances: 0},
    name: '',
    network: {
      forwardedPorts: [],
      instanceIpMode: '',
      instanceTag: '',
      name: '',
      sessionAffinity: false,
      subnetworkName: ''
    },
    nobuildFilesRegex: '',
    readinessCheck: {
      appStartTimeout: '',
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    resources: {
      cpu: '',
      diskGb: '',
      kmsKeyReference: '',
      memoryGb: '',
      volumes: [{name: '', sizeGb: '', volumeType: ''}]
    },
    runtime: '',
    runtimeApiVersion: '',
    runtimeChannel: '',
    runtimeMainExecutablePath: '',
    serviceAccount: '',
    servingStatus: '',
    threadsafe: false,
    versionUrl: '',
    vm: false,
    vpcAccessConnector: {egressSetting: '', name: ''},
    zones: []
  }
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"apiConfig":{"authFailAction":"","login":"","script":"","securityLevel":"","url":""},"appEngineApis":false,"automaticScaling":{"coolDownPeriod":"","cpuUtilization":{"aggregationWindowLength":"","targetUtilization":""},"customMetrics":[{"filter":"","metricName":"","singleInstanceAssignment":"","targetType":"","targetUtilization":""}],"diskUtilization":{"targetReadBytesPerSecond":0,"targetReadOpsPerSecond":0,"targetWriteBytesPerSecond":0,"targetWriteOpsPerSecond":0},"maxConcurrentRequests":0,"maxIdleInstances":0,"maxPendingLatency":"","maxTotalInstances":0,"minIdleInstances":0,"minPendingLatency":"","minTotalInstances":0,"networkUtilization":{"targetReceivedBytesPerSecond":0,"targetReceivedPacketsPerSecond":0,"targetSentBytesPerSecond":0,"targetSentPacketsPerSecond":0},"requestUtilization":{"targetConcurrentRequests":0,"targetRequestCountPerSecond":0},"standardSchedulerSettings":{"maxInstances":0,"minInstances":0,"targetCpuUtilization":"","targetThroughputUtilization":""}},"basicScaling":{"idleTimeout":"","maxInstances":0},"betaSettings":{},"buildEnvVariables":{},"createTime":"","createdBy":"","defaultExpiration":"","deployment":{"build":{"cloudBuildId":""},"cloudBuildOptions":{"appYamlPath":"","cloudBuildTimeout":""},"container":{"image":""},"files":{},"zip":{"filesCount":0,"sourceUrl":""}},"diskUsageBytes":"","endpointsApiService":{"configId":"","disableTraceSampling":false,"name":"","rolloutStrategy":""},"entrypoint":{"shell":""},"env":"","envVariables":{},"errorHandlers":[{"errorCode":"","mimeType":"","staticFile":""}],"flexibleRuntimeSettings":{"operatingSystem":"","runtimeVersion":""},"handlers":[{"apiEndpoint":{"scriptPath":""},"authFailAction":"","login":"","redirectHttpResponseCode":"","script":{"scriptPath":""},"securityLevel":"","staticFiles":{"applicationReadable":false,"expiration":"","httpHeaders":{},"mimeType":"","path":"","requireMatchingFile":false,"uploadPathRegex":""},"urlRegex":""}],"healthCheck":{"checkInterval":"","disableHealthCheck":false,"healthyThreshold":0,"host":"","restartThreshold":0,"timeout":"","unhealthyThreshold":0},"id":"","inboundServices":[],"instanceClass":"","libraries":[{"name":"","version":""}],"livenessCheck":{"checkInterval":"","failureThreshold":0,"host":"","initialDelay":"","path":"","successThreshold":0,"timeout":""},"manualScaling":{"instances":0},"name":"","network":{"forwardedPorts":[],"instanceIpMode":"","instanceTag":"","name":"","sessionAffinity":false,"subnetworkName":""},"nobuildFilesRegex":"","readinessCheck":{"appStartTimeout":"","checkInterval":"","failureThreshold":0,"host":"","path":"","successThreshold":0,"timeout":""},"resources":{"cpu":"","diskGb":"","kmsKeyReference":"","memoryGb":"","volumes":[{"name":"","sizeGb":"","volumeType":""}]},"runtime":"","runtimeApiVersion":"","runtimeChannel":"","runtimeMainExecutablePath":"","serviceAccount":"","servingStatus":"","threadsafe":false,"versionUrl":"","vm":false,"vpcAccessConnector":{"egressSetting":"","name":""},"zones":[]}'
};

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}}/v1beta/apps/:appsId/services/:servicesId/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "apiConfig": {\n    "authFailAction": "",\n    "login": "",\n    "script": "",\n    "securityLevel": "",\n    "url": ""\n  },\n  "appEngineApis": false,\n  "automaticScaling": {\n    "coolDownPeriod": "",\n    "cpuUtilization": {\n      "aggregationWindowLength": "",\n      "targetUtilization": ""\n    },\n    "customMetrics": [\n      {\n        "filter": "",\n        "metricName": "",\n        "singleInstanceAssignment": "",\n        "targetType": "",\n        "targetUtilization": ""\n      }\n    ],\n    "diskUtilization": {\n      "targetReadBytesPerSecond": 0,\n      "targetReadOpsPerSecond": 0,\n      "targetWriteBytesPerSecond": 0,\n      "targetWriteOpsPerSecond": 0\n    },\n    "maxConcurrentRequests": 0,\n    "maxIdleInstances": 0,\n    "maxPendingLatency": "",\n    "maxTotalInstances": 0,\n    "minIdleInstances": 0,\n    "minPendingLatency": "",\n    "minTotalInstances": 0,\n    "networkUtilization": {\n      "targetReceivedBytesPerSecond": 0,\n      "targetReceivedPacketsPerSecond": 0,\n      "targetSentBytesPerSecond": 0,\n      "targetSentPacketsPerSecond": 0\n    },\n    "requestUtilization": {\n      "targetConcurrentRequests": 0,\n      "targetRequestCountPerSecond": 0\n    },\n    "standardSchedulerSettings": {\n      "maxInstances": 0,\n      "minInstances": 0,\n      "targetCpuUtilization": "",\n      "targetThroughputUtilization": ""\n    }\n  },\n  "basicScaling": {\n    "idleTimeout": "",\n    "maxInstances": 0\n  },\n  "betaSettings": {},\n  "buildEnvVariables": {},\n  "createTime": "",\n  "createdBy": "",\n  "defaultExpiration": "",\n  "deployment": {\n    "build": {\n      "cloudBuildId": ""\n    },\n    "cloudBuildOptions": {\n      "appYamlPath": "",\n      "cloudBuildTimeout": ""\n    },\n    "container": {\n      "image": ""\n    },\n    "files": {},\n    "zip": {\n      "filesCount": 0,\n      "sourceUrl": ""\n    }\n  },\n  "diskUsageBytes": "",\n  "endpointsApiService": {\n    "configId": "",\n    "disableTraceSampling": false,\n    "name": "",\n    "rolloutStrategy": ""\n  },\n  "entrypoint": {\n    "shell": ""\n  },\n  "env": "",\n  "envVariables": {},\n  "errorHandlers": [\n    {\n      "errorCode": "",\n      "mimeType": "",\n      "staticFile": ""\n    }\n  ],\n  "flexibleRuntimeSettings": {\n    "operatingSystem": "",\n    "runtimeVersion": ""\n  },\n  "handlers": [\n    {\n      "apiEndpoint": {\n        "scriptPath": ""\n      },\n      "authFailAction": "",\n      "login": "",\n      "redirectHttpResponseCode": "",\n      "script": {\n        "scriptPath": ""\n      },\n      "securityLevel": "",\n      "staticFiles": {\n        "applicationReadable": false,\n        "expiration": "",\n        "httpHeaders": {},\n        "mimeType": "",\n        "path": "",\n        "requireMatchingFile": false,\n        "uploadPathRegex": ""\n      },\n      "urlRegex": ""\n    }\n  ],\n  "healthCheck": {\n    "checkInterval": "",\n    "disableHealthCheck": false,\n    "healthyThreshold": 0,\n    "host": "",\n    "restartThreshold": 0,\n    "timeout": "",\n    "unhealthyThreshold": 0\n  },\n  "id": "",\n  "inboundServices": [],\n  "instanceClass": "",\n  "libraries": [\n    {\n      "name": "",\n      "version": ""\n    }\n  ],\n  "livenessCheck": {\n    "checkInterval": "",\n    "failureThreshold": 0,\n    "host": "",\n    "initialDelay": "",\n    "path": "",\n    "successThreshold": 0,\n    "timeout": ""\n  },\n  "manualScaling": {\n    "instances": 0\n  },\n  "name": "",\n  "network": {\n    "forwardedPorts": [],\n    "instanceIpMode": "",\n    "instanceTag": "",\n    "name": "",\n    "sessionAffinity": false,\n    "subnetworkName": ""\n  },\n  "nobuildFilesRegex": "",\n  "readinessCheck": {\n    "appStartTimeout": "",\n    "checkInterval": "",\n    "failureThreshold": 0,\n    "host": "",\n    "path": "",\n    "successThreshold": 0,\n    "timeout": ""\n  },\n  "resources": {\n    "cpu": "",\n    "diskGb": "",\n    "kmsKeyReference": "",\n    "memoryGb": "",\n    "volumes": [\n      {\n        "name": "",\n        "sizeGb": "",\n        "volumeType": ""\n      }\n    ]\n  },\n  "runtime": "",\n  "runtimeApiVersion": "",\n  "runtimeChannel": "",\n  "runtimeMainExecutablePath": "",\n  "serviceAccount": "",\n  "servingStatus": "",\n  "threadsafe": false,\n  "versionUrl": "",\n  "vm": false,\n  "vpcAccessConnector": {\n    "egressSetting": "",\n    "name": ""\n  },\n  "zones": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")
  .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/v1beta/apps/:appsId/services/:servicesId/versions',
  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({
  apiConfig: {authFailAction: '', login: '', script: '', securityLevel: '', url: ''},
  appEngineApis: false,
  automaticScaling: {
    coolDownPeriod: '',
    cpuUtilization: {aggregationWindowLength: '', targetUtilization: ''},
    customMetrics: [
      {
        filter: '',
        metricName: '',
        singleInstanceAssignment: '',
        targetType: '',
        targetUtilization: ''
      }
    ],
    diskUtilization: {
      targetReadBytesPerSecond: 0,
      targetReadOpsPerSecond: 0,
      targetWriteBytesPerSecond: 0,
      targetWriteOpsPerSecond: 0
    },
    maxConcurrentRequests: 0,
    maxIdleInstances: 0,
    maxPendingLatency: '',
    maxTotalInstances: 0,
    minIdleInstances: 0,
    minPendingLatency: '',
    minTotalInstances: 0,
    networkUtilization: {
      targetReceivedBytesPerSecond: 0,
      targetReceivedPacketsPerSecond: 0,
      targetSentBytesPerSecond: 0,
      targetSentPacketsPerSecond: 0
    },
    requestUtilization: {targetConcurrentRequests: 0, targetRequestCountPerSecond: 0},
    standardSchedulerSettings: {
      maxInstances: 0,
      minInstances: 0,
      targetCpuUtilization: '',
      targetThroughputUtilization: ''
    }
  },
  basicScaling: {idleTimeout: '', maxInstances: 0},
  betaSettings: {},
  buildEnvVariables: {},
  createTime: '',
  createdBy: '',
  defaultExpiration: '',
  deployment: {
    build: {cloudBuildId: ''},
    cloudBuildOptions: {appYamlPath: '', cloudBuildTimeout: ''},
    container: {image: ''},
    files: {},
    zip: {filesCount: 0, sourceUrl: ''}
  },
  diskUsageBytes: '',
  endpointsApiService: {configId: '', disableTraceSampling: false, name: '', rolloutStrategy: ''},
  entrypoint: {shell: ''},
  env: '',
  envVariables: {},
  errorHandlers: [{errorCode: '', mimeType: '', staticFile: ''}],
  flexibleRuntimeSettings: {operatingSystem: '', runtimeVersion: ''},
  handlers: [
    {
      apiEndpoint: {scriptPath: ''},
      authFailAction: '',
      login: '',
      redirectHttpResponseCode: '',
      script: {scriptPath: ''},
      securityLevel: '',
      staticFiles: {
        applicationReadable: false,
        expiration: '',
        httpHeaders: {},
        mimeType: '',
        path: '',
        requireMatchingFile: false,
        uploadPathRegex: ''
      },
      urlRegex: ''
    }
  ],
  healthCheck: {
    checkInterval: '',
    disableHealthCheck: false,
    healthyThreshold: 0,
    host: '',
    restartThreshold: 0,
    timeout: '',
    unhealthyThreshold: 0
  },
  id: '',
  inboundServices: [],
  instanceClass: '',
  libraries: [{name: '', version: ''}],
  livenessCheck: {
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    initialDelay: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  manualScaling: {instances: 0},
  name: '',
  network: {
    forwardedPorts: [],
    instanceIpMode: '',
    instanceTag: '',
    name: '',
    sessionAffinity: false,
    subnetworkName: ''
  },
  nobuildFilesRegex: '',
  readinessCheck: {
    appStartTimeout: '',
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  resources: {
    cpu: '',
    diskGb: '',
    kmsKeyReference: '',
    memoryGb: '',
    volumes: [{name: '', sizeGb: '', volumeType: ''}]
  },
  runtime: '',
  runtimeApiVersion: '',
  runtimeChannel: '',
  runtimeMainExecutablePath: '',
  serviceAccount: '',
  servingStatus: '',
  threadsafe: false,
  versionUrl: '',
  vm: false,
  vpcAccessConnector: {egressSetting: '', name: ''},
  zones: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions',
  headers: {'content-type': 'application/json'},
  body: {
    apiConfig: {authFailAction: '', login: '', script: '', securityLevel: '', url: ''},
    appEngineApis: false,
    automaticScaling: {
      coolDownPeriod: '',
      cpuUtilization: {aggregationWindowLength: '', targetUtilization: ''},
      customMetrics: [
        {
          filter: '',
          metricName: '',
          singleInstanceAssignment: '',
          targetType: '',
          targetUtilization: ''
        }
      ],
      diskUtilization: {
        targetReadBytesPerSecond: 0,
        targetReadOpsPerSecond: 0,
        targetWriteBytesPerSecond: 0,
        targetWriteOpsPerSecond: 0
      },
      maxConcurrentRequests: 0,
      maxIdleInstances: 0,
      maxPendingLatency: '',
      maxTotalInstances: 0,
      minIdleInstances: 0,
      minPendingLatency: '',
      minTotalInstances: 0,
      networkUtilization: {
        targetReceivedBytesPerSecond: 0,
        targetReceivedPacketsPerSecond: 0,
        targetSentBytesPerSecond: 0,
        targetSentPacketsPerSecond: 0
      },
      requestUtilization: {targetConcurrentRequests: 0, targetRequestCountPerSecond: 0},
      standardSchedulerSettings: {
        maxInstances: 0,
        minInstances: 0,
        targetCpuUtilization: '',
        targetThroughputUtilization: ''
      }
    },
    basicScaling: {idleTimeout: '', maxInstances: 0},
    betaSettings: {},
    buildEnvVariables: {},
    createTime: '',
    createdBy: '',
    defaultExpiration: '',
    deployment: {
      build: {cloudBuildId: ''},
      cloudBuildOptions: {appYamlPath: '', cloudBuildTimeout: ''},
      container: {image: ''},
      files: {},
      zip: {filesCount: 0, sourceUrl: ''}
    },
    diskUsageBytes: '',
    endpointsApiService: {configId: '', disableTraceSampling: false, name: '', rolloutStrategy: ''},
    entrypoint: {shell: ''},
    env: '',
    envVariables: {},
    errorHandlers: [{errorCode: '', mimeType: '', staticFile: ''}],
    flexibleRuntimeSettings: {operatingSystem: '', runtimeVersion: ''},
    handlers: [
      {
        apiEndpoint: {scriptPath: ''},
        authFailAction: '',
        login: '',
        redirectHttpResponseCode: '',
        script: {scriptPath: ''},
        securityLevel: '',
        staticFiles: {
          applicationReadable: false,
          expiration: '',
          httpHeaders: {},
          mimeType: '',
          path: '',
          requireMatchingFile: false,
          uploadPathRegex: ''
        },
        urlRegex: ''
      }
    ],
    healthCheck: {
      checkInterval: '',
      disableHealthCheck: false,
      healthyThreshold: 0,
      host: '',
      restartThreshold: 0,
      timeout: '',
      unhealthyThreshold: 0
    },
    id: '',
    inboundServices: [],
    instanceClass: '',
    libraries: [{name: '', version: ''}],
    livenessCheck: {
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      initialDelay: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    manualScaling: {instances: 0},
    name: '',
    network: {
      forwardedPorts: [],
      instanceIpMode: '',
      instanceTag: '',
      name: '',
      sessionAffinity: false,
      subnetworkName: ''
    },
    nobuildFilesRegex: '',
    readinessCheck: {
      appStartTimeout: '',
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    resources: {
      cpu: '',
      diskGb: '',
      kmsKeyReference: '',
      memoryGb: '',
      volumes: [{name: '', sizeGb: '', volumeType: ''}]
    },
    runtime: '',
    runtimeApiVersion: '',
    runtimeChannel: '',
    runtimeMainExecutablePath: '',
    serviceAccount: '',
    servingStatus: '',
    threadsafe: false,
    versionUrl: '',
    vm: false,
    vpcAccessConnector: {egressSetting: '', name: ''},
    zones: []
  },
  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}}/v1beta/apps/:appsId/services/:servicesId/versions');

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

req.type('json');
req.send({
  apiConfig: {
    authFailAction: '',
    login: '',
    script: '',
    securityLevel: '',
    url: ''
  },
  appEngineApis: false,
  automaticScaling: {
    coolDownPeriod: '',
    cpuUtilization: {
      aggregationWindowLength: '',
      targetUtilization: ''
    },
    customMetrics: [
      {
        filter: '',
        metricName: '',
        singleInstanceAssignment: '',
        targetType: '',
        targetUtilization: ''
      }
    ],
    diskUtilization: {
      targetReadBytesPerSecond: 0,
      targetReadOpsPerSecond: 0,
      targetWriteBytesPerSecond: 0,
      targetWriteOpsPerSecond: 0
    },
    maxConcurrentRequests: 0,
    maxIdleInstances: 0,
    maxPendingLatency: '',
    maxTotalInstances: 0,
    minIdleInstances: 0,
    minPendingLatency: '',
    minTotalInstances: 0,
    networkUtilization: {
      targetReceivedBytesPerSecond: 0,
      targetReceivedPacketsPerSecond: 0,
      targetSentBytesPerSecond: 0,
      targetSentPacketsPerSecond: 0
    },
    requestUtilization: {
      targetConcurrentRequests: 0,
      targetRequestCountPerSecond: 0
    },
    standardSchedulerSettings: {
      maxInstances: 0,
      minInstances: 0,
      targetCpuUtilization: '',
      targetThroughputUtilization: ''
    }
  },
  basicScaling: {
    idleTimeout: '',
    maxInstances: 0
  },
  betaSettings: {},
  buildEnvVariables: {},
  createTime: '',
  createdBy: '',
  defaultExpiration: '',
  deployment: {
    build: {
      cloudBuildId: ''
    },
    cloudBuildOptions: {
      appYamlPath: '',
      cloudBuildTimeout: ''
    },
    container: {
      image: ''
    },
    files: {},
    zip: {
      filesCount: 0,
      sourceUrl: ''
    }
  },
  diskUsageBytes: '',
  endpointsApiService: {
    configId: '',
    disableTraceSampling: false,
    name: '',
    rolloutStrategy: ''
  },
  entrypoint: {
    shell: ''
  },
  env: '',
  envVariables: {},
  errorHandlers: [
    {
      errorCode: '',
      mimeType: '',
      staticFile: ''
    }
  ],
  flexibleRuntimeSettings: {
    operatingSystem: '',
    runtimeVersion: ''
  },
  handlers: [
    {
      apiEndpoint: {
        scriptPath: ''
      },
      authFailAction: '',
      login: '',
      redirectHttpResponseCode: '',
      script: {
        scriptPath: ''
      },
      securityLevel: '',
      staticFiles: {
        applicationReadable: false,
        expiration: '',
        httpHeaders: {},
        mimeType: '',
        path: '',
        requireMatchingFile: false,
        uploadPathRegex: ''
      },
      urlRegex: ''
    }
  ],
  healthCheck: {
    checkInterval: '',
    disableHealthCheck: false,
    healthyThreshold: 0,
    host: '',
    restartThreshold: 0,
    timeout: '',
    unhealthyThreshold: 0
  },
  id: '',
  inboundServices: [],
  instanceClass: '',
  libraries: [
    {
      name: '',
      version: ''
    }
  ],
  livenessCheck: {
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    initialDelay: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  manualScaling: {
    instances: 0
  },
  name: '',
  network: {
    forwardedPorts: [],
    instanceIpMode: '',
    instanceTag: '',
    name: '',
    sessionAffinity: false,
    subnetworkName: ''
  },
  nobuildFilesRegex: '',
  readinessCheck: {
    appStartTimeout: '',
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  resources: {
    cpu: '',
    diskGb: '',
    kmsKeyReference: '',
    memoryGb: '',
    volumes: [
      {
        name: '',
        sizeGb: '',
        volumeType: ''
      }
    ]
  },
  runtime: '',
  runtimeApiVersion: '',
  runtimeChannel: '',
  runtimeMainExecutablePath: '',
  serviceAccount: '',
  servingStatus: '',
  threadsafe: false,
  versionUrl: '',
  vm: false,
  vpcAccessConnector: {
    egressSetting: '',
    name: ''
  },
  zones: []
});

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}}/v1beta/apps/:appsId/services/:servicesId/versions',
  headers: {'content-type': 'application/json'},
  data: {
    apiConfig: {authFailAction: '', login: '', script: '', securityLevel: '', url: ''},
    appEngineApis: false,
    automaticScaling: {
      coolDownPeriod: '',
      cpuUtilization: {aggregationWindowLength: '', targetUtilization: ''},
      customMetrics: [
        {
          filter: '',
          metricName: '',
          singleInstanceAssignment: '',
          targetType: '',
          targetUtilization: ''
        }
      ],
      diskUtilization: {
        targetReadBytesPerSecond: 0,
        targetReadOpsPerSecond: 0,
        targetWriteBytesPerSecond: 0,
        targetWriteOpsPerSecond: 0
      },
      maxConcurrentRequests: 0,
      maxIdleInstances: 0,
      maxPendingLatency: '',
      maxTotalInstances: 0,
      minIdleInstances: 0,
      minPendingLatency: '',
      minTotalInstances: 0,
      networkUtilization: {
        targetReceivedBytesPerSecond: 0,
        targetReceivedPacketsPerSecond: 0,
        targetSentBytesPerSecond: 0,
        targetSentPacketsPerSecond: 0
      },
      requestUtilization: {targetConcurrentRequests: 0, targetRequestCountPerSecond: 0},
      standardSchedulerSettings: {
        maxInstances: 0,
        minInstances: 0,
        targetCpuUtilization: '',
        targetThroughputUtilization: ''
      }
    },
    basicScaling: {idleTimeout: '', maxInstances: 0},
    betaSettings: {},
    buildEnvVariables: {},
    createTime: '',
    createdBy: '',
    defaultExpiration: '',
    deployment: {
      build: {cloudBuildId: ''},
      cloudBuildOptions: {appYamlPath: '', cloudBuildTimeout: ''},
      container: {image: ''},
      files: {},
      zip: {filesCount: 0, sourceUrl: ''}
    },
    diskUsageBytes: '',
    endpointsApiService: {configId: '', disableTraceSampling: false, name: '', rolloutStrategy: ''},
    entrypoint: {shell: ''},
    env: '',
    envVariables: {},
    errorHandlers: [{errorCode: '', mimeType: '', staticFile: ''}],
    flexibleRuntimeSettings: {operatingSystem: '', runtimeVersion: ''},
    handlers: [
      {
        apiEndpoint: {scriptPath: ''},
        authFailAction: '',
        login: '',
        redirectHttpResponseCode: '',
        script: {scriptPath: ''},
        securityLevel: '',
        staticFiles: {
          applicationReadable: false,
          expiration: '',
          httpHeaders: {},
          mimeType: '',
          path: '',
          requireMatchingFile: false,
          uploadPathRegex: ''
        },
        urlRegex: ''
      }
    ],
    healthCheck: {
      checkInterval: '',
      disableHealthCheck: false,
      healthyThreshold: 0,
      host: '',
      restartThreshold: 0,
      timeout: '',
      unhealthyThreshold: 0
    },
    id: '',
    inboundServices: [],
    instanceClass: '',
    libraries: [{name: '', version: ''}],
    livenessCheck: {
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      initialDelay: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    manualScaling: {instances: 0},
    name: '',
    network: {
      forwardedPorts: [],
      instanceIpMode: '',
      instanceTag: '',
      name: '',
      sessionAffinity: false,
      subnetworkName: ''
    },
    nobuildFilesRegex: '',
    readinessCheck: {
      appStartTimeout: '',
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    resources: {
      cpu: '',
      diskGb: '',
      kmsKeyReference: '',
      memoryGb: '',
      volumes: [{name: '', sizeGb: '', volumeType: ''}]
    },
    runtime: '',
    runtimeApiVersion: '',
    runtimeChannel: '',
    runtimeMainExecutablePath: '',
    serviceAccount: '',
    servingStatus: '',
    threadsafe: false,
    versionUrl: '',
    vm: false,
    vpcAccessConnector: {egressSetting: '', name: ''},
    zones: []
  }
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"apiConfig":{"authFailAction":"","login":"","script":"","securityLevel":"","url":""},"appEngineApis":false,"automaticScaling":{"coolDownPeriod":"","cpuUtilization":{"aggregationWindowLength":"","targetUtilization":""},"customMetrics":[{"filter":"","metricName":"","singleInstanceAssignment":"","targetType":"","targetUtilization":""}],"diskUtilization":{"targetReadBytesPerSecond":0,"targetReadOpsPerSecond":0,"targetWriteBytesPerSecond":0,"targetWriteOpsPerSecond":0},"maxConcurrentRequests":0,"maxIdleInstances":0,"maxPendingLatency":"","maxTotalInstances":0,"minIdleInstances":0,"minPendingLatency":"","minTotalInstances":0,"networkUtilization":{"targetReceivedBytesPerSecond":0,"targetReceivedPacketsPerSecond":0,"targetSentBytesPerSecond":0,"targetSentPacketsPerSecond":0},"requestUtilization":{"targetConcurrentRequests":0,"targetRequestCountPerSecond":0},"standardSchedulerSettings":{"maxInstances":0,"minInstances":0,"targetCpuUtilization":"","targetThroughputUtilization":""}},"basicScaling":{"idleTimeout":"","maxInstances":0},"betaSettings":{},"buildEnvVariables":{},"createTime":"","createdBy":"","defaultExpiration":"","deployment":{"build":{"cloudBuildId":""},"cloudBuildOptions":{"appYamlPath":"","cloudBuildTimeout":""},"container":{"image":""},"files":{},"zip":{"filesCount":0,"sourceUrl":""}},"diskUsageBytes":"","endpointsApiService":{"configId":"","disableTraceSampling":false,"name":"","rolloutStrategy":""},"entrypoint":{"shell":""},"env":"","envVariables":{},"errorHandlers":[{"errorCode":"","mimeType":"","staticFile":""}],"flexibleRuntimeSettings":{"operatingSystem":"","runtimeVersion":""},"handlers":[{"apiEndpoint":{"scriptPath":""},"authFailAction":"","login":"","redirectHttpResponseCode":"","script":{"scriptPath":""},"securityLevel":"","staticFiles":{"applicationReadable":false,"expiration":"","httpHeaders":{},"mimeType":"","path":"","requireMatchingFile":false,"uploadPathRegex":""},"urlRegex":""}],"healthCheck":{"checkInterval":"","disableHealthCheck":false,"healthyThreshold":0,"host":"","restartThreshold":0,"timeout":"","unhealthyThreshold":0},"id":"","inboundServices":[],"instanceClass":"","libraries":[{"name":"","version":""}],"livenessCheck":{"checkInterval":"","failureThreshold":0,"host":"","initialDelay":"","path":"","successThreshold":0,"timeout":""},"manualScaling":{"instances":0},"name":"","network":{"forwardedPorts":[],"instanceIpMode":"","instanceTag":"","name":"","sessionAffinity":false,"subnetworkName":""},"nobuildFilesRegex":"","readinessCheck":{"appStartTimeout":"","checkInterval":"","failureThreshold":0,"host":"","path":"","successThreshold":0,"timeout":""},"resources":{"cpu":"","diskGb":"","kmsKeyReference":"","memoryGb":"","volumes":[{"name":"","sizeGb":"","volumeType":""}]},"runtime":"","runtimeApiVersion":"","runtimeChannel":"","runtimeMainExecutablePath":"","serviceAccount":"","servingStatus":"","threadsafe":false,"versionUrl":"","vm":false,"vpcAccessConnector":{"egressSetting":"","name":""},"zones":[]}'
};

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 = @{ @"apiConfig": @{ @"authFailAction": @"", @"login": @"", @"script": @"", @"securityLevel": @"", @"url": @"" },
                              @"appEngineApis": @NO,
                              @"automaticScaling": @{ @"coolDownPeriod": @"", @"cpuUtilization": @{ @"aggregationWindowLength": @"", @"targetUtilization": @"" }, @"customMetrics": @[ @{ @"filter": @"", @"metricName": @"", @"singleInstanceAssignment": @"", @"targetType": @"", @"targetUtilization": @"" } ], @"diskUtilization": @{ @"targetReadBytesPerSecond": @0, @"targetReadOpsPerSecond": @0, @"targetWriteBytesPerSecond": @0, @"targetWriteOpsPerSecond": @0 }, @"maxConcurrentRequests": @0, @"maxIdleInstances": @0, @"maxPendingLatency": @"", @"maxTotalInstances": @0, @"minIdleInstances": @0, @"minPendingLatency": @"", @"minTotalInstances": @0, @"networkUtilization": @{ @"targetReceivedBytesPerSecond": @0, @"targetReceivedPacketsPerSecond": @0, @"targetSentBytesPerSecond": @0, @"targetSentPacketsPerSecond": @0 }, @"requestUtilization": @{ @"targetConcurrentRequests": @0, @"targetRequestCountPerSecond": @0 }, @"standardSchedulerSettings": @{ @"maxInstances": @0, @"minInstances": @0, @"targetCpuUtilization": @"", @"targetThroughputUtilization": @"" } },
                              @"basicScaling": @{ @"idleTimeout": @"", @"maxInstances": @0 },
                              @"betaSettings": @{  },
                              @"buildEnvVariables": @{  },
                              @"createTime": @"",
                              @"createdBy": @"",
                              @"defaultExpiration": @"",
                              @"deployment": @{ @"build": @{ @"cloudBuildId": @"" }, @"cloudBuildOptions": @{ @"appYamlPath": @"", @"cloudBuildTimeout": @"" }, @"container": @{ @"image": @"" }, @"files": @{  }, @"zip": @{ @"filesCount": @0, @"sourceUrl": @"" } },
                              @"diskUsageBytes": @"",
                              @"endpointsApiService": @{ @"configId": @"", @"disableTraceSampling": @NO, @"name": @"", @"rolloutStrategy": @"" },
                              @"entrypoint": @{ @"shell": @"" },
                              @"env": @"",
                              @"envVariables": @{  },
                              @"errorHandlers": @[ @{ @"errorCode": @"", @"mimeType": @"", @"staticFile": @"" } ],
                              @"flexibleRuntimeSettings": @{ @"operatingSystem": @"", @"runtimeVersion": @"" },
                              @"handlers": @[ @{ @"apiEndpoint": @{ @"scriptPath": @"" }, @"authFailAction": @"", @"login": @"", @"redirectHttpResponseCode": @"", @"script": @{ @"scriptPath": @"" }, @"securityLevel": @"", @"staticFiles": @{ @"applicationReadable": @NO, @"expiration": @"", @"httpHeaders": @{  }, @"mimeType": @"", @"path": @"", @"requireMatchingFile": @NO, @"uploadPathRegex": @"" }, @"urlRegex": @"" } ],
                              @"healthCheck": @{ @"checkInterval": @"", @"disableHealthCheck": @NO, @"healthyThreshold": @0, @"host": @"", @"restartThreshold": @0, @"timeout": @"", @"unhealthyThreshold": @0 },
                              @"id": @"",
                              @"inboundServices": @[  ],
                              @"instanceClass": @"",
                              @"libraries": @[ @{ @"name": @"", @"version": @"" } ],
                              @"livenessCheck": @{ @"checkInterval": @"", @"failureThreshold": @0, @"host": @"", @"initialDelay": @"", @"path": @"", @"successThreshold": @0, @"timeout": @"" },
                              @"manualScaling": @{ @"instances": @0 },
                              @"name": @"",
                              @"network": @{ @"forwardedPorts": @[  ], @"instanceIpMode": @"", @"instanceTag": @"", @"name": @"", @"sessionAffinity": @NO, @"subnetworkName": @"" },
                              @"nobuildFilesRegex": @"",
                              @"readinessCheck": @{ @"appStartTimeout": @"", @"checkInterval": @"", @"failureThreshold": @0, @"host": @"", @"path": @"", @"successThreshold": @0, @"timeout": @"" },
                              @"resources": @{ @"cpu": @"", @"diskGb": @"", @"kmsKeyReference": @"", @"memoryGb": @"", @"volumes": @[ @{ @"name": @"", @"sizeGb": @"", @"volumeType": @"" } ] },
                              @"runtime": @"",
                              @"runtimeApiVersion": @"",
                              @"runtimeChannel": @"",
                              @"runtimeMainExecutablePath": @"",
                              @"serviceAccount": @"",
                              @"servingStatus": @"",
                              @"threadsafe": @NO,
                              @"versionUrl": @"",
                              @"vm": @NO,
                              @"vpcAccessConnector": @{ @"egressSetting": @"", @"name": @"" },
                              @"zones": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions"]
                                                       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}}/v1beta/apps/:appsId/services/:servicesId/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions",
  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([
    'apiConfig' => [
        'authFailAction' => '',
        'login' => '',
        'script' => '',
        'securityLevel' => '',
        'url' => ''
    ],
    'appEngineApis' => null,
    'automaticScaling' => [
        'coolDownPeriod' => '',
        'cpuUtilization' => [
                'aggregationWindowLength' => '',
                'targetUtilization' => ''
        ],
        'customMetrics' => [
                [
                                'filter' => '',
                                'metricName' => '',
                                'singleInstanceAssignment' => '',
                                'targetType' => '',
                                'targetUtilization' => ''
                ]
        ],
        'diskUtilization' => [
                'targetReadBytesPerSecond' => 0,
                'targetReadOpsPerSecond' => 0,
                'targetWriteBytesPerSecond' => 0,
                'targetWriteOpsPerSecond' => 0
        ],
        'maxConcurrentRequests' => 0,
        'maxIdleInstances' => 0,
        'maxPendingLatency' => '',
        'maxTotalInstances' => 0,
        'minIdleInstances' => 0,
        'minPendingLatency' => '',
        'minTotalInstances' => 0,
        'networkUtilization' => [
                'targetReceivedBytesPerSecond' => 0,
                'targetReceivedPacketsPerSecond' => 0,
                'targetSentBytesPerSecond' => 0,
                'targetSentPacketsPerSecond' => 0
        ],
        'requestUtilization' => [
                'targetConcurrentRequests' => 0,
                'targetRequestCountPerSecond' => 0
        ],
        'standardSchedulerSettings' => [
                'maxInstances' => 0,
                'minInstances' => 0,
                'targetCpuUtilization' => '',
                'targetThroughputUtilization' => ''
        ]
    ],
    'basicScaling' => [
        'idleTimeout' => '',
        'maxInstances' => 0
    ],
    'betaSettings' => [
        
    ],
    'buildEnvVariables' => [
        
    ],
    'createTime' => '',
    'createdBy' => '',
    'defaultExpiration' => '',
    'deployment' => [
        'build' => [
                'cloudBuildId' => ''
        ],
        'cloudBuildOptions' => [
                'appYamlPath' => '',
                'cloudBuildTimeout' => ''
        ],
        'container' => [
                'image' => ''
        ],
        'files' => [
                
        ],
        'zip' => [
                'filesCount' => 0,
                'sourceUrl' => ''
        ]
    ],
    'diskUsageBytes' => '',
    'endpointsApiService' => [
        'configId' => '',
        'disableTraceSampling' => null,
        'name' => '',
        'rolloutStrategy' => ''
    ],
    'entrypoint' => [
        'shell' => ''
    ],
    'env' => '',
    'envVariables' => [
        
    ],
    'errorHandlers' => [
        [
                'errorCode' => '',
                'mimeType' => '',
                'staticFile' => ''
        ]
    ],
    'flexibleRuntimeSettings' => [
        'operatingSystem' => '',
        'runtimeVersion' => ''
    ],
    'handlers' => [
        [
                'apiEndpoint' => [
                                'scriptPath' => ''
                ],
                'authFailAction' => '',
                'login' => '',
                'redirectHttpResponseCode' => '',
                'script' => [
                                'scriptPath' => ''
                ],
                'securityLevel' => '',
                'staticFiles' => [
                                'applicationReadable' => null,
                                'expiration' => '',
                                'httpHeaders' => [
                                                                
                                ],
                                'mimeType' => '',
                                'path' => '',
                                'requireMatchingFile' => null,
                                'uploadPathRegex' => ''
                ],
                'urlRegex' => ''
        ]
    ],
    'healthCheck' => [
        'checkInterval' => '',
        'disableHealthCheck' => null,
        'healthyThreshold' => 0,
        'host' => '',
        'restartThreshold' => 0,
        'timeout' => '',
        'unhealthyThreshold' => 0
    ],
    'id' => '',
    'inboundServices' => [
        
    ],
    'instanceClass' => '',
    'libraries' => [
        [
                'name' => '',
                'version' => ''
        ]
    ],
    'livenessCheck' => [
        'checkInterval' => '',
        'failureThreshold' => 0,
        'host' => '',
        'initialDelay' => '',
        'path' => '',
        'successThreshold' => 0,
        'timeout' => ''
    ],
    'manualScaling' => [
        'instances' => 0
    ],
    'name' => '',
    'network' => [
        'forwardedPorts' => [
                
        ],
        'instanceIpMode' => '',
        'instanceTag' => '',
        'name' => '',
        'sessionAffinity' => null,
        'subnetworkName' => ''
    ],
    'nobuildFilesRegex' => '',
    'readinessCheck' => [
        'appStartTimeout' => '',
        'checkInterval' => '',
        'failureThreshold' => 0,
        'host' => '',
        'path' => '',
        'successThreshold' => 0,
        'timeout' => ''
    ],
    'resources' => [
        'cpu' => '',
        'diskGb' => '',
        'kmsKeyReference' => '',
        'memoryGb' => '',
        'volumes' => [
                [
                                'name' => '',
                                'sizeGb' => '',
                                'volumeType' => ''
                ]
        ]
    ],
    'runtime' => '',
    'runtimeApiVersion' => '',
    'runtimeChannel' => '',
    'runtimeMainExecutablePath' => '',
    'serviceAccount' => '',
    'servingStatus' => '',
    'threadsafe' => null,
    'versionUrl' => '',
    'vm' => null,
    'vpcAccessConnector' => [
        'egressSetting' => '',
        'name' => ''
    ],
    'zones' => [
        
    ]
  ]),
  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}}/v1beta/apps/:appsId/services/:servicesId/versions', [
  'body' => '{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'apiConfig' => [
    'authFailAction' => '',
    'login' => '',
    'script' => '',
    'securityLevel' => '',
    'url' => ''
  ],
  'appEngineApis' => null,
  'automaticScaling' => [
    'coolDownPeriod' => '',
    'cpuUtilization' => [
        'aggregationWindowLength' => '',
        'targetUtilization' => ''
    ],
    'customMetrics' => [
        [
                'filter' => '',
                'metricName' => '',
                'singleInstanceAssignment' => '',
                'targetType' => '',
                'targetUtilization' => ''
        ]
    ],
    'diskUtilization' => [
        'targetReadBytesPerSecond' => 0,
        'targetReadOpsPerSecond' => 0,
        'targetWriteBytesPerSecond' => 0,
        'targetWriteOpsPerSecond' => 0
    ],
    'maxConcurrentRequests' => 0,
    'maxIdleInstances' => 0,
    'maxPendingLatency' => '',
    'maxTotalInstances' => 0,
    'minIdleInstances' => 0,
    'minPendingLatency' => '',
    'minTotalInstances' => 0,
    'networkUtilization' => [
        'targetReceivedBytesPerSecond' => 0,
        'targetReceivedPacketsPerSecond' => 0,
        'targetSentBytesPerSecond' => 0,
        'targetSentPacketsPerSecond' => 0
    ],
    'requestUtilization' => [
        'targetConcurrentRequests' => 0,
        'targetRequestCountPerSecond' => 0
    ],
    'standardSchedulerSettings' => [
        'maxInstances' => 0,
        'minInstances' => 0,
        'targetCpuUtilization' => '',
        'targetThroughputUtilization' => ''
    ]
  ],
  'basicScaling' => [
    'idleTimeout' => '',
    'maxInstances' => 0
  ],
  'betaSettings' => [
    
  ],
  'buildEnvVariables' => [
    
  ],
  'createTime' => '',
  'createdBy' => '',
  'defaultExpiration' => '',
  'deployment' => [
    'build' => [
        'cloudBuildId' => ''
    ],
    'cloudBuildOptions' => [
        'appYamlPath' => '',
        'cloudBuildTimeout' => ''
    ],
    'container' => [
        'image' => ''
    ],
    'files' => [
        
    ],
    'zip' => [
        'filesCount' => 0,
        'sourceUrl' => ''
    ]
  ],
  'diskUsageBytes' => '',
  'endpointsApiService' => [
    'configId' => '',
    'disableTraceSampling' => null,
    'name' => '',
    'rolloutStrategy' => ''
  ],
  'entrypoint' => [
    'shell' => ''
  ],
  'env' => '',
  'envVariables' => [
    
  ],
  'errorHandlers' => [
    [
        'errorCode' => '',
        'mimeType' => '',
        'staticFile' => ''
    ]
  ],
  'flexibleRuntimeSettings' => [
    'operatingSystem' => '',
    'runtimeVersion' => ''
  ],
  'handlers' => [
    [
        'apiEndpoint' => [
                'scriptPath' => ''
        ],
        'authFailAction' => '',
        'login' => '',
        'redirectHttpResponseCode' => '',
        'script' => [
                'scriptPath' => ''
        ],
        'securityLevel' => '',
        'staticFiles' => [
                'applicationReadable' => null,
                'expiration' => '',
                'httpHeaders' => [
                                
                ],
                'mimeType' => '',
                'path' => '',
                'requireMatchingFile' => null,
                'uploadPathRegex' => ''
        ],
        'urlRegex' => ''
    ]
  ],
  'healthCheck' => [
    'checkInterval' => '',
    'disableHealthCheck' => null,
    'healthyThreshold' => 0,
    'host' => '',
    'restartThreshold' => 0,
    'timeout' => '',
    'unhealthyThreshold' => 0
  ],
  'id' => '',
  'inboundServices' => [
    
  ],
  'instanceClass' => '',
  'libraries' => [
    [
        'name' => '',
        'version' => ''
    ]
  ],
  'livenessCheck' => [
    'checkInterval' => '',
    'failureThreshold' => 0,
    'host' => '',
    'initialDelay' => '',
    'path' => '',
    'successThreshold' => 0,
    'timeout' => ''
  ],
  'manualScaling' => [
    'instances' => 0
  ],
  'name' => '',
  'network' => [
    'forwardedPorts' => [
        
    ],
    'instanceIpMode' => '',
    'instanceTag' => '',
    'name' => '',
    'sessionAffinity' => null,
    'subnetworkName' => ''
  ],
  'nobuildFilesRegex' => '',
  'readinessCheck' => [
    'appStartTimeout' => '',
    'checkInterval' => '',
    'failureThreshold' => 0,
    'host' => '',
    'path' => '',
    'successThreshold' => 0,
    'timeout' => ''
  ],
  'resources' => [
    'cpu' => '',
    'diskGb' => '',
    'kmsKeyReference' => '',
    'memoryGb' => '',
    'volumes' => [
        [
                'name' => '',
                'sizeGb' => '',
                'volumeType' => ''
        ]
    ]
  ],
  'runtime' => '',
  'runtimeApiVersion' => '',
  'runtimeChannel' => '',
  'runtimeMainExecutablePath' => '',
  'serviceAccount' => '',
  'servingStatus' => '',
  'threadsafe' => null,
  'versionUrl' => '',
  'vm' => null,
  'vpcAccessConnector' => [
    'egressSetting' => '',
    'name' => ''
  ],
  'zones' => [
    
  ]
]));

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

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

append(json_encode([
  'apiConfig' => [
    'authFailAction' => '',
    'login' => '',
    'script' => '',
    'securityLevel' => '',
    'url' => ''
  ],
  'appEngineApis' => null,
  'automaticScaling' => [
    'coolDownPeriod' => '',
    'cpuUtilization' => [
        'aggregationWindowLength' => '',
        'targetUtilization' => ''
    ],
    'customMetrics' => [
        [
                'filter' => '',
                'metricName' => '',
                'singleInstanceAssignment' => '',
                'targetType' => '',
                'targetUtilization' => ''
        ]
    ],
    'diskUtilization' => [
        'targetReadBytesPerSecond' => 0,
        'targetReadOpsPerSecond' => 0,
        'targetWriteBytesPerSecond' => 0,
        'targetWriteOpsPerSecond' => 0
    ],
    'maxConcurrentRequests' => 0,
    'maxIdleInstances' => 0,
    'maxPendingLatency' => '',
    'maxTotalInstances' => 0,
    'minIdleInstances' => 0,
    'minPendingLatency' => '',
    'minTotalInstances' => 0,
    'networkUtilization' => [
        'targetReceivedBytesPerSecond' => 0,
        'targetReceivedPacketsPerSecond' => 0,
        'targetSentBytesPerSecond' => 0,
        'targetSentPacketsPerSecond' => 0
    ],
    'requestUtilization' => [
        'targetConcurrentRequests' => 0,
        'targetRequestCountPerSecond' => 0
    ],
    'standardSchedulerSettings' => [
        'maxInstances' => 0,
        'minInstances' => 0,
        'targetCpuUtilization' => '',
        'targetThroughputUtilization' => ''
    ]
  ],
  'basicScaling' => [
    'idleTimeout' => '',
    'maxInstances' => 0
  ],
  'betaSettings' => [
    
  ],
  'buildEnvVariables' => [
    
  ],
  'createTime' => '',
  'createdBy' => '',
  'defaultExpiration' => '',
  'deployment' => [
    'build' => [
        'cloudBuildId' => ''
    ],
    'cloudBuildOptions' => [
        'appYamlPath' => '',
        'cloudBuildTimeout' => ''
    ],
    'container' => [
        'image' => ''
    ],
    'files' => [
        
    ],
    'zip' => [
        'filesCount' => 0,
        'sourceUrl' => ''
    ]
  ],
  'diskUsageBytes' => '',
  'endpointsApiService' => [
    'configId' => '',
    'disableTraceSampling' => null,
    'name' => '',
    'rolloutStrategy' => ''
  ],
  'entrypoint' => [
    'shell' => ''
  ],
  'env' => '',
  'envVariables' => [
    
  ],
  'errorHandlers' => [
    [
        'errorCode' => '',
        'mimeType' => '',
        'staticFile' => ''
    ]
  ],
  'flexibleRuntimeSettings' => [
    'operatingSystem' => '',
    'runtimeVersion' => ''
  ],
  'handlers' => [
    [
        'apiEndpoint' => [
                'scriptPath' => ''
        ],
        'authFailAction' => '',
        'login' => '',
        'redirectHttpResponseCode' => '',
        'script' => [
                'scriptPath' => ''
        ],
        'securityLevel' => '',
        'staticFiles' => [
                'applicationReadable' => null,
                'expiration' => '',
                'httpHeaders' => [
                                
                ],
                'mimeType' => '',
                'path' => '',
                'requireMatchingFile' => null,
                'uploadPathRegex' => ''
        ],
        'urlRegex' => ''
    ]
  ],
  'healthCheck' => [
    'checkInterval' => '',
    'disableHealthCheck' => null,
    'healthyThreshold' => 0,
    'host' => '',
    'restartThreshold' => 0,
    'timeout' => '',
    'unhealthyThreshold' => 0
  ],
  'id' => '',
  'inboundServices' => [
    
  ],
  'instanceClass' => '',
  'libraries' => [
    [
        'name' => '',
        'version' => ''
    ]
  ],
  'livenessCheck' => [
    'checkInterval' => '',
    'failureThreshold' => 0,
    'host' => '',
    'initialDelay' => '',
    'path' => '',
    'successThreshold' => 0,
    'timeout' => ''
  ],
  'manualScaling' => [
    'instances' => 0
  ],
  'name' => '',
  'network' => [
    'forwardedPorts' => [
        
    ],
    'instanceIpMode' => '',
    'instanceTag' => '',
    'name' => '',
    'sessionAffinity' => null,
    'subnetworkName' => ''
  ],
  'nobuildFilesRegex' => '',
  'readinessCheck' => [
    'appStartTimeout' => '',
    'checkInterval' => '',
    'failureThreshold' => 0,
    'host' => '',
    'path' => '',
    'successThreshold' => 0,
    'timeout' => ''
  ],
  'resources' => [
    'cpu' => '',
    'diskGb' => '',
    'kmsKeyReference' => '',
    'memoryGb' => '',
    'volumes' => [
        [
                'name' => '',
                'sizeGb' => '',
                'volumeType' => ''
        ]
    ]
  ],
  'runtime' => '',
  'runtimeApiVersion' => '',
  'runtimeChannel' => '',
  'runtimeMainExecutablePath' => '',
  'serviceAccount' => '',
  'servingStatus' => '',
  'threadsafe' => null,
  'versionUrl' => '',
  'vm' => null,
  'vpcAccessConnector' => [
    'egressSetting' => '',
    'name' => ''
  ],
  'zones' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions');
$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}}/v1beta/apps/:appsId/services/:servicesId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}'

import http.client

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

payload = "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}"

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

conn.request("POST", "/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions"

payload = {
    "apiConfig": {
        "authFailAction": "",
        "login": "",
        "script": "",
        "securityLevel": "",
        "url": ""
    },
    "appEngineApis": False,
    "automaticScaling": {
        "coolDownPeriod": "",
        "cpuUtilization": {
            "aggregationWindowLength": "",
            "targetUtilization": ""
        },
        "customMetrics": [
            {
                "filter": "",
                "metricName": "",
                "singleInstanceAssignment": "",
                "targetType": "",
                "targetUtilization": ""
            }
        ],
        "diskUtilization": {
            "targetReadBytesPerSecond": 0,
            "targetReadOpsPerSecond": 0,
            "targetWriteBytesPerSecond": 0,
            "targetWriteOpsPerSecond": 0
        },
        "maxConcurrentRequests": 0,
        "maxIdleInstances": 0,
        "maxPendingLatency": "",
        "maxTotalInstances": 0,
        "minIdleInstances": 0,
        "minPendingLatency": "",
        "minTotalInstances": 0,
        "networkUtilization": {
            "targetReceivedBytesPerSecond": 0,
            "targetReceivedPacketsPerSecond": 0,
            "targetSentBytesPerSecond": 0,
            "targetSentPacketsPerSecond": 0
        },
        "requestUtilization": {
            "targetConcurrentRequests": 0,
            "targetRequestCountPerSecond": 0
        },
        "standardSchedulerSettings": {
            "maxInstances": 0,
            "minInstances": 0,
            "targetCpuUtilization": "",
            "targetThroughputUtilization": ""
        }
    },
    "basicScaling": {
        "idleTimeout": "",
        "maxInstances": 0
    },
    "betaSettings": {},
    "buildEnvVariables": {},
    "createTime": "",
    "createdBy": "",
    "defaultExpiration": "",
    "deployment": {
        "build": { "cloudBuildId": "" },
        "cloudBuildOptions": {
            "appYamlPath": "",
            "cloudBuildTimeout": ""
        },
        "container": { "image": "" },
        "files": {},
        "zip": {
            "filesCount": 0,
            "sourceUrl": ""
        }
    },
    "diskUsageBytes": "",
    "endpointsApiService": {
        "configId": "",
        "disableTraceSampling": False,
        "name": "",
        "rolloutStrategy": ""
    },
    "entrypoint": { "shell": "" },
    "env": "",
    "envVariables": {},
    "errorHandlers": [
        {
            "errorCode": "",
            "mimeType": "",
            "staticFile": ""
        }
    ],
    "flexibleRuntimeSettings": {
        "operatingSystem": "",
        "runtimeVersion": ""
    },
    "handlers": [
        {
            "apiEndpoint": { "scriptPath": "" },
            "authFailAction": "",
            "login": "",
            "redirectHttpResponseCode": "",
            "script": { "scriptPath": "" },
            "securityLevel": "",
            "staticFiles": {
                "applicationReadable": False,
                "expiration": "",
                "httpHeaders": {},
                "mimeType": "",
                "path": "",
                "requireMatchingFile": False,
                "uploadPathRegex": ""
            },
            "urlRegex": ""
        }
    ],
    "healthCheck": {
        "checkInterval": "",
        "disableHealthCheck": False,
        "healthyThreshold": 0,
        "host": "",
        "restartThreshold": 0,
        "timeout": "",
        "unhealthyThreshold": 0
    },
    "id": "",
    "inboundServices": [],
    "instanceClass": "",
    "libraries": [
        {
            "name": "",
            "version": ""
        }
    ],
    "livenessCheck": {
        "checkInterval": "",
        "failureThreshold": 0,
        "host": "",
        "initialDelay": "",
        "path": "",
        "successThreshold": 0,
        "timeout": ""
    },
    "manualScaling": { "instances": 0 },
    "name": "",
    "network": {
        "forwardedPorts": [],
        "instanceIpMode": "",
        "instanceTag": "",
        "name": "",
        "sessionAffinity": False,
        "subnetworkName": ""
    },
    "nobuildFilesRegex": "",
    "readinessCheck": {
        "appStartTimeout": "",
        "checkInterval": "",
        "failureThreshold": 0,
        "host": "",
        "path": "",
        "successThreshold": 0,
        "timeout": ""
    },
    "resources": {
        "cpu": "",
        "diskGb": "",
        "kmsKeyReference": "",
        "memoryGb": "",
        "volumes": [
            {
                "name": "",
                "sizeGb": "",
                "volumeType": ""
            }
        ]
    },
    "runtime": "",
    "runtimeApiVersion": "",
    "runtimeChannel": "",
    "runtimeMainExecutablePath": "",
    "serviceAccount": "",
    "servingStatus": "",
    "threadsafe": False,
    "versionUrl": "",
    "vm": False,
    "vpcAccessConnector": {
        "egressSetting": "",
        "name": ""
    },
    "zones": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions"

payload <- "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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}}/v1beta/apps/:appsId/services/:servicesId/versions")

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  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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/v1beta/apps/:appsId/services/:servicesId/versions') do |req|
  req.body = "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions";

    let payload = json!({
        "apiConfig": json!({
            "authFailAction": "",
            "login": "",
            "script": "",
            "securityLevel": "",
            "url": ""
        }),
        "appEngineApis": false,
        "automaticScaling": json!({
            "coolDownPeriod": "",
            "cpuUtilization": json!({
                "aggregationWindowLength": "",
                "targetUtilization": ""
            }),
            "customMetrics": (
                json!({
                    "filter": "",
                    "metricName": "",
                    "singleInstanceAssignment": "",
                    "targetType": "",
                    "targetUtilization": ""
                })
            ),
            "diskUtilization": json!({
                "targetReadBytesPerSecond": 0,
                "targetReadOpsPerSecond": 0,
                "targetWriteBytesPerSecond": 0,
                "targetWriteOpsPerSecond": 0
            }),
            "maxConcurrentRequests": 0,
            "maxIdleInstances": 0,
            "maxPendingLatency": "",
            "maxTotalInstances": 0,
            "minIdleInstances": 0,
            "minPendingLatency": "",
            "minTotalInstances": 0,
            "networkUtilization": json!({
                "targetReceivedBytesPerSecond": 0,
                "targetReceivedPacketsPerSecond": 0,
                "targetSentBytesPerSecond": 0,
                "targetSentPacketsPerSecond": 0
            }),
            "requestUtilization": json!({
                "targetConcurrentRequests": 0,
                "targetRequestCountPerSecond": 0
            }),
            "standardSchedulerSettings": json!({
                "maxInstances": 0,
                "minInstances": 0,
                "targetCpuUtilization": "",
                "targetThroughputUtilization": ""
            })
        }),
        "basicScaling": json!({
            "idleTimeout": "",
            "maxInstances": 0
        }),
        "betaSettings": json!({}),
        "buildEnvVariables": json!({}),
        "createTime": "",
        "createdBy": "",
        "defaultExpiration": "",
        "deployment": json!({
            "build": json!({"cloudBuildId": ""}),
            "cloudBuildOptions": json!({
                "appYamlPath": "",
                "cloudBuildTimeout": ""
            }),
            "container": json!({"image": ""}),
            "files": json!({}),
            "zip": json!({
                "filesCount": 0,
                "sourceUrl": ""
            })
        }),
        "diskUsageBytes": "",
        "endpointsApiService": json!({
            "configId": "",
            "disableTraceSampling": false,
            "name": "",
            "rolloutStrategy": ""
        }),
        "entrypoint": json!({"shell": ""}),
        "env": "",
        "envVariables": json!({}),
        "errorHandlers": (
            json!({
                "errorCode": "",
                "mimeType": "",
                "staticFile": ""
            })
        ),
        "flexibleRuntimeSettings": json!({
            "operatingSystem": "",
            "runtimeVersion": ""
        }),
        "handlers": (
            json!({
                "apiEndpoint": json!({"scriptPath": ""}),
                "authFailAction": "",
                "login": "",
                "redirectHttpResponseCode": "",
                "script": json!({"scriptPath": ""}),
                "securityLevel": "",
                "staticFiles": json!({
                    "applicationReadable": false,
                    "expiration": "",
                    "httpHeaders": json!({}),
                    "mimeType": "",
                    "path": "",
                    "requireMatchingFile": false,
                    "uploadPathRegex": ""
                }),
                "urlRegex": ""
            })
        ),
        "healthCheck": json!({
            "checkInterval": "",
            "disableHealthCheck": false,
            "healthyThreshold": 0,
            "host": "",
            "restartThreshold": 0,
            "timeout": "",
            "unhealthyThreshold": 0
        }),
        "id": "",
        "inboundServices": (),
        "instanceClass": "",
        "libraries": (
            json!({
                "name": "",
                "version": ""
            })
        ),
        "livenessCheck": json!({
            "checkInterval": "",
            "failureThreshold": 0,
            "host": "",
            "initialDelay": "",
            "path": "",
            "successThreshold": 0,
            "timeout": ""
        }),
        "manualScaling": json!({"instances": 0}),
        "name": "",
        "network": json!({
            "forwardedPorts": (),
            "instanceIpMode": "",
            "instanceTag": "",
            "name": "",
            "sessionAffinity": false,
            "subnetworkName": ""
        }),
        "nobuildFilesRegex": "",
        "readinessCheck": json!({
            "appStartTimeout": "",
            "checkInterval": "",
            "failureThreshold": 0,
            "host": "",
            "path": "",
            "successThreshold": 0,
            "timeout": ""
        }),
        "resources": json!({
            "cpu": "",
            "diskGb": "",
            "kmsKeyReference": "",
            "memoryGb": "",
            "volumes": (
                json!({
                    "name": "",
                    "sizeGb": "",
                    "volumeType": ""
                })
            )
        }),
        "runtime": "",
        "runtimeApiVersion": "",
        "runtimeChannel": "",
        "runtimeMainExecutablePath": "",
        "serviceAccount": "",
        "servingStatus": "",
        "threadsafe": false,
        "versionUrl": "",
        "vm": false,
        "vpcAccessConnector": json!({
            "egressSetting": "",
            "name": ""
        }),
        "zones": ()
    });

    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}}/v1beta/apps/:appsId/services/:servicesId/versions \
  --header 'content-type: application/json' \
  --data '{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}'

echo '{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}' |  \
  http POST {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "apiConfig": {\n    "authFailAction": "",\n    "login": "",\n    "script": "",\n    "securityLevel": "",\n    "url": ""\n  },\n  "appEngineApis": false,\n  "automaticScaling": {\n    "coolDownPeriod": "",\n    "cpuUtilization": {\n      "aggregationWindowLength": "",\n      "targetUtilization": ""\n    },\n    "customMetrics": [\n      {\n        "filter": "",\n        "metricName": "",\n        "singleInstanceAssignment": "",\n        "targetType": "",\n        "targetUtilization": ""\n      }\n    ],\n    "diskUtilization": {\n      "targetReadBytesPerSecond": 0,\n      "targetReadOpsPerSecond": 0,\n      "targetWriteBytesPerSecond": 0,\n      "targetWriteOpsPerSecond": 0\n    },\n    "maxConcurrentRequests": 0,\n    "maxIdleInstances": 0,\n    "maxPendingLatency": "",\n    "maxTotalInstances": 0,\n    "minIdleInstances": 0,\n    "minPendingLatency": "",\n    "minTotalInstances": 0,\n    "networkUtilization": {\n      "targetReceivedBytesPerSecond": 0,\n      "targetReceivedPacketsPerSecond": 0,\n      "targetSentBytesPerSecond": 0,\n      "targetSentPacketsPerSecond": 0\n    },\n    "requestUtilization": {\n      "targetConcurrentRequests": 0,\n      "targetRequestCountPerSecond": 0\n    },\n    "standardSchedulerSettings": {\n      "maxInstances": 0,\n      "minInstances": 0,\n      "targetCpuUtilization": "",\n      "targetThroughputUtilization": ""\n    }\n  },\n  "basicScaling": {\n    "idleTimeout": "",\n    "maxInstances": 0\n  },\n  "betaSettings": {},\n  "buildEnvVariables": {},\n  "createTime": "",\n  "createdBy": "",\n  "defaultExpiration": "",\n  "deployment": {\n    "build": {\n      "cloudBuildId": ""\n    },\n    "cloudBuildOptions": {\n      "appYamlPath": "",\n      "cloudBuildTimeout": ""\n    },\n    "container": {\n      "image": ""\n    },\n    "files": {},\n    "zip": {\n      "filesCount": 0,\n      "sourceUrl": ""\n    }\n  },\n  "diskUsageBytes": "",\n  "endpointsApiService": {\n    "configId": "",\n    "disableTraceSampling": false,\n    "name": "",\n    "rolloutStrategy": ""\n  },\n  "entrypoint": {\n    "shell": ""\n  },\n  "env": "",\n  "envVariables": {},\n  "errorHandlers": [\n    {\n      "errorCode": "",\n      "mimeType": "",\n      "staticFile": ""\n    }\n  ],\n  "flexibleRuntimeSettings": {\n    "operatingSystem": "",\n    "runtimeVersion": ""\n  },\n  "handlers": [\n    {\n      "apiEndpoint": {\n        "scriptPath": ""\n      },\n      "authFailAction": "",\n      "login": "",\n      "redirectHttpResponseCode": "",\n      "script": {\n        "scriptPath": ""\n      },\n      "securityLevel": "",\n      "staticFiles": {\n        "applicationReadable": false,\n        "expiration": "",\n        "httpHeaders": {},\n        "mimeType": "",\n        "path": "",\n        "requireMatchingFile": false,\n        "uploadPathRegex": ""\n      },\n      "urlRegex": ""\n    }\n  ],\n  "healthCheck": {\n    "checkInterval": "",\n    "disableHealthCheck": false,\n    "healthyThreshold": 0,\n    "host": "",\n    "restartThreshold": 0,\n    "timeout": "",\n    "unhealthyThreshold": 0\n  },\n  "id": "",\n  "inboundServices": [],\n  "instanceClass": "",\n  "libraries": [\n    {\n      "name": "",\n      "version": ""\n    }\n  ],\n  "livenessCheck": {\n    "checkInterval": "",\n    "failureThreshold": 0,\n    "host": "",\n    "initialDelay": "",\n    "path": "",\n    "successThreshold": 0,\n    "timeout": ""\n  },\n  "manualScaling": {\n    "instances": 0\n  },\n  "name": "",\n  "network": {\n    "forwardedPorts": [],\n    "instanceIpMode": "",\n    "instanceTag": "",\n    "name": "",\n    "sessionAffinity": false,\n    "subnetworkName": ""\n  },\n  "nobuildFilesRegex": "",\n  "readinessCheck": {\n    "appStartTimeout": "",\n    "checkInterval": "",\n    "failureThreshold": 0,\n    "host": "",\n    "path": "",\n    "successThreshold": 0,\n    "timeout": ""\n  },\n  "resources": {\n    "cpu": "",\n    "diskGb": "",\n    "kmsKeyReference": "",\n    "memoryGb": "",\n    "volumes": [\n      {\n        "name": "",\n        "sizeGb": "",\n        "volumeType": ""\n      }\n    ]\n  },\n  "runtime": "",\n  "runtimeApiVersion": "",\n  "runtimeChannel": "",\n  "runtimeMainExecutablePath": "",\n  "serviceAccount": "",\n  "servingStatus": "",\n  "threadsafe": false,\n  "versionUrl": "",\n  "vm": false,\n  "vpcAccessConnector": {\n    "egressSetting": "",\n    "name": ""\n  },\n  "zones": []\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "apiConfig": [
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  ],
  "appEngineApis": false,
  "automaticScaling": [
    "coolDownPeriod": "",
    "cpuUtilization": [
      "aggregationWindowLength": "",
      "targetUtilization": ""
    ],
    "customMetrics": [
      [
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      ]
    ],
    "diskUtilization": [
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    ],
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": [
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    ],
    "requestUtilization": [
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    ],
    "standardSchedulerSettings": [
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    ]
  ],
  "basicScaling": [
    "idleTimeout": "",
    "maxInstances": 0
  ],
  "betaSettings": [],
  "buildEnvVariables": [],
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": [
    "build": ["cloudBuildId": ""],
    "cloudBuildOptions": [
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    ],
    "container": ["image": ""],
    "files": [],
    "zip": [
      "filesCount": 0,
      "sourceUrl": ""
    ]
  ],
  "diskUsageBytes": "",
  "endpointsApiService": [
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  ],
  "entrypoint": ["shell": ""],
  "env": "",
  "envVariables": [],
  "errorHandlers": [
    [
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    ]
  ],
  "flexibleRuntimeSettings": [
    "operatingSystem": "",
    "runtimeVersion": ""
  ],
  "handlers": [
    [
      "apiEndpoint": ["scriptPath": ""],
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": ["scriptPath": ""],
      "securityLevel": "",
      "staticFiles": [
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": [],
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      ],
      "urlRegex": ""
    ]
  ],
  "healthCheck": [
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  ],
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    [
      "name": "",
      "version": ""
    ]
  ],
  "livenessCheck": [
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  ],
  "manualScaling": ["instances": 0],
  "name": "",
  "network": [
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  ],
  "nobuildFilesRegex": "",
  "readinessCheck": [
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  ],
  "resources": [
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      [
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      ]
    ]
  ],
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": [
    "egressSetting": "",
    "name": ""
  ],
  "zones": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")! 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 appengine.apps.services.versions.delete

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId

QUERY PARAMS

appsId

servicesId

versionsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"

	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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"))
    .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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId';
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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId',
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId';
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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"]
                                                       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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId",
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")

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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId";

    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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId

http DELETE {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")! 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 appengine.apps.services.versions.get

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId

QUERY PARAMS

appsId

servicesId

versionsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"

	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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"))
    .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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId';
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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId',
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId';
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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"]
                                                       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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId",
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")

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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId";

    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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId

http GET {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")! 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 appengine.apps.services.versions.instances.debug

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug

QUERY PARAMS

appsId

servicesId

versionsId

instancesId

BODY json

{
  "sshKey": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug");

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  \"sshKey\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug" {:content-type :json
                                                                                                                                       :form-params {:sshKey ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"sshKey\": \"\"\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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug"),
    Content = new StringContent("{\n  \"sshKey\": \"\"\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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"sshKey\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug"

	payload := strings.NewReader("{\n  \"sshKey\": \"\"\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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 18

{
  "sshKey": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"sshKey\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"sshKey\": \"\"\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  \"sshKey\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug")
  .header("content-type", "application/json")
  .body("{\n  \"sshKey\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  sshKey: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug',
  headers: {'content-type': 'application/json'},
  data: {sshKey: ''}
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"sshKey":""}'
};

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "sshKey": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"sshKey\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug")
  .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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug',
  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({sshKey: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug',
  headers: {'content-type': 'application/json'},
  body: {sshKey: ''},
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug');

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

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

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug',
  headers: {'content-type': 'application/json'},
  data: {sshKey: ''}
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"sshKey":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug"]
                                                       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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"sshKey\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug",
  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([
    'sshKey' => ''
  ]),
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug', [
  'body' => '{
  "sshKey": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'sshKey' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug');
$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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "sshKey": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "sshKey": ""
}'

import http.client

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

payload = "{\n  \"sshKey\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug"

payload <- "{\n  \"sshKey\": \"\"\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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug")

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  \"sshKey\": \"\"\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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug') do |req|
  req.body = "{\n  \"sshKey\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug";

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

    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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug \
  --header 'content-type: application/json' \
  --data '{
  "sshKey": ""
}'

echo '{
  "sshKey": ""
}' |  \
  http POST {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "sshKey": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId:debug")! 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 appengine.apps.services.versions.instances.delete

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId

QUERY PARAMS

appsId

servicesId

versionsId

instancesId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"

	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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"))
    .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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")
  .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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId';
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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId',
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId');

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId';
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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"]
                                                       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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId",
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")

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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId";

    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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId

http DELETE {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")! 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 appengine.apps.services.versions.instances.get

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId

QUERY PARAMS

appsId

servicesId

versionsId

instancesId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"

	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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"))
    .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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")
  .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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId';
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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId',
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId');

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId';
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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"]
                                                       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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId",
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")

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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId";

    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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId

http GET {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances/:instancesId")! 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 appengine.apps.services.versions.instances.list

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances

QUERY PARAMS

appsId

servicesId

versionsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances"

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

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

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

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

}

GET /baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances

http GET {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId/instances")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

GET appengine.apps.services.versions.list

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions

QUERY PARAMS

appsId

servicesId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions"

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

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

var client = new RestClient("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions"

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

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

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

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

}

GET /baseUrl/v1beta/apps/:appsId/services/:servicesId/versions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions'
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions'
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions")

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

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

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions

http GET {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

PATCH appengine.apps.services.versions.patch

{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId

QUERY PARAMS

appsId

servicesId

versionsId

BODY json

{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId");

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  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId" {:content-type :json
                                                                                                           :form-params {:apiConfig {:authFailAction ""
                                                                                                                                     :login ""
                                                                                                                                     :script ""
                                                                                                                                     :securityLevel ""
                                                                                                                                     :url ""}
                                                                                                                         :appEngineApis false
                                                                                                                         :automaticScaling {:coolDownPeriod ""
                                                                                                                                            :cpuUtilization {:aggregationWindowLength ""
                                                                                                                                                             :targetUtilization ""}
                                                                                                                                            :customMetrics [{:filter ""
                                                                                                                                                             :metricName ""
                                                                                                                                                             :singleInstanceAssignment ""
                                                                                                                                                             :targetType ""
                                                                                                                                                             :targetUtilization ""}]
                                                                                                                                            :diskUtilization {:targetReadBytesPerSecond 0
                                                                                                                                                              :targetReadOpsPerSecond 0
                                                                                                                                                              :targetWriteBytesPerSecond 0
                                                                                                                                                              :targetWriteOpsPerSecond 0}
                                                                                                                                            :maxConcurrentRequests 0
                                                                                                                                            :maxIdleInstances 0
                                                                                                                                            :maxPendingLatency ""
                                                                                                                                            :maxTotalInstances 0
                                                                                                                                            :minIdleInstances 0
                                                                                                                                            :minPendingLatency ""
                                                                                                                                            :minTotalInstances 0
                                                                                                                                            :networkUtilization {:targetReceivedBytesPerSecond 0
                                                                                                                                                                 :targetReceivedPacketsPerSecond 0
                                                                                                                                                                 :targetSentBytesPerSecond 0
                                                                                                                                                                 :targetSentPacketsPerSecond 0}
                                                                                                                                            :requestUtilization {:targetConcurrentRequests 0
                                                                                                                                                                 :targetRequestCountPerSecond 0}
                                                                                                                                            :standardSchedulerSettings {:maxInstances 0
                                                                                                                                                                        :minInstances 0
                                                                                                                                                                        :targetCpuUtilization ""
                                                                                                                                                                        :targetThroughputUtilization ""}}
                                                                                                                         :basicScaling {:idleTimeout ""
                                                                                                                                        :maxInstances 0}
                                                                                                                         :betaSettings {}
                                                                                                                         :buildEnvVariables {}
                                                                                                                         :createTime ""
                                                                                                                         :createdBy ""
                                                                                                                         :defaultExpiration ""
                                                                                                                         :deployment {:build {:cloudBuildId ""}
                                                                                                                                      :cloudBuildOptions {:appYamlPath ""
                                                                                                                                                          :cloudBuildTimeout ""}
                                                                                                                                      :container {:image ""}
                                                                                                                                      :files {}
                                                                                                                                      :zip {:filesCount 0
                                                                                                                                            :sourceUrl ""}}
                                                                                                                         :diskUsageBytes ""
                                                                                                                         :endpointsApiService {:configId ""
                                                                                                                                               :disableTraceSampling false
                                                                                                                                               :name ""
                                                                                                                                               :rolloutStrategy ""}
                                                                                                                         :entrypoint {:shell ""}
                                                                                                                         :env ""
                                                                                                                         :envVariables {}
                                                                                                                         :errorHandlers [{:errorCode ""
                                                                                                                                          :mimeType ""
                                                                                                                                          :staticFile ""}]
                                                                                                                         :flexibleRuntimeSettings {:operatingSystem ""
                                                                                                                                                   :runtimeVersion ""}
                                                                                                                         :handlers [{:apiEndpoint {:scriptPath ""}
                                                                                                                                     :authFailAction ""
                                                                                                                                     :login ""
                                                                                                                                     :redirectHttpResponseCode ""
                                                                                                                                     :script {:scriptPath ""}
                                                                                                                                     :securityLevel ""
                                                                                                                                     :staticFiles {:applicationReadable false
                                                                                                                                                   :expiration ""
                                                                                                                                                   :httpHeaders {}
                                                                                                                                                   :mimeType ""
                                                                                                                                                   :path ""
                                                                                                                                                   :requireMatchingFile false
                                                                                                                                                   :uploadPathRegex ""}
                                                                                                                                     :urlRegex ""}]
                                                                                                                         :healthCheck {:checkInterval ""
                                                                                                                                       :disableHealthCheck false
                                                                                                                                       :healthyThreshold 0
                                                                                                                                       :host ""
                                                                                                                                       :restartThreshold 0
                                                                                                                                       :timeout ""
                                                                                                                                       :unhealthyThreshold 0}
                                                                                                                         :id ""
                                                                                                                         :inboundServices []
                                                                                                                         :instanceClass ""
                                                                                                                         :libraries [{:name ""
                                                                                                                                      :version ""}]
                                                                                                                         :livenessCheck {:checkInterval ""
                                                                                                                                         :failureThreshold 0
                                                                                                                                         :host ""
                                                                                                                                         :initialDelay ""
                                                                                                                                         :path ""
                                                                                                                                         :successThreshold 0
                                                                                                                                         :timeout ""}
                                                                                                                         :manualScaling {:instances 0}
                                                                                                                         :name ""
                                                                                                                         :network {:forwardedPorts []
                                                                                                                                   :instanceIpMode ""
                                                                                                                                   :instanceTag ""
                                                                                                                                   :name ""
                                                                                                                                   :sessionAffinity false
                                                                                                                                   :subnetworkName ""}
                                                                                                                         :nobuildFilesRegex ""
                                                                                                                         :readinessCheck {:appStartTimeout ""
                                                                                                                                          :checkInterval ""
                                                                                                                                          :failureThreshold 0
                                                                                                                                          :host ""
                                                                                                                                          :path ""
                                                                                                                                          :successThreshold 0
                                                                                                                                          :timeout ""}
                                                                                                                         :resources {:cpu ""
                                                                                                                                     :diskGb ""
                                                                                                                                     :kmsKeyReference ""
                                                                                                                                     :memoryGb ""
                                                                                                                                     :volumes [{:name ""
                                                                                                                                                :sizeGb ""
                                                                                                                                                :volumeType ""}]}
                                                                                                                         :runtime ""
                                                                                                                         :runtimeApiVersion ""
                                                                                                                         :runtimeChannel ""
                                                                                                                         :runtimeMainExecutablePath ""
                                                                                                                         :serviceAccount ""
                                                                                                                         :servingStatus ""
                                                                                                                         :threadsafe false
                                                                                                                         :versionUrl ""
                                                                                                                         :vm false
                                                                                                                         :vpcAccessConnector {:egressSetting ""
                                                                                                                                              :name ""}
                                                                                                                         :zones []}})

require "http/client"

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"),
    Content = new StringContent("{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"

	payload := strings.NewReader("{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 4189

{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .header("content-type", "application/json")
  .body("{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}")
  .asString();

const data = JSON.stringify({
  apiConfig: {
    authFailAction: '',
    login: '',
    script: '',
    securityLevel: '',
    url: ''
  },
  appEngineApis: false,
  automaticScaling: {
    coolDownPeriod: '',
    cpuUtilization: {
      aggregationWindowLength: '',
      targetUtilization: ''
    },
    customMetrics: [
      {
        filter: '',
        metricName: '',
        singleInstanceAssignment: '',
        targetType: '',
        targetUtilization: ''
      }
    ],
    diskUtilization: {
      targetReadBytesPerSecond: 0,
      targetReadOpsPerSecond: 0,
      targetWriteBytesPerSecond: 0,
      targetWriteOpsPerSecond: 0
    },
    maxConcurrentRequests: 0,
    maxIdleInstances: 0,
    maxPendingLatency: '',
    maxTotalInstances: 0,
    minIdleInstances: 0,
    minPendingLatency: '',
    minTotalInstances: 0,
    networkUtilization: {
      targetReceivedBytesPerSecond: 0,
      targetReceivedPacketsPerSecond: 0,
      targetSentBytesPerSecond: 0,
      targetSentPacketsPerSecond: 0
    },
    requestUtilization: {
      targetConcurrentRequests: 0,
      targetRequestCountPerSecond: 0
    },
    standardSchedulerSettings: {
      maxInstances: 0,
      minInstances: 0,
      targetCpuUtilization: '',
      targetThroughputUtilization: ''
    }
  },
  basicScaling: {
    idleTimeout: '',
    maxInstances: 0
  },
  betaSettings: {},
  buildEnvVariables: {},
  createTime: '',
  createdBy: '',
  defaultExpiration: '',
  deployment: {
    build: {
      cloudBuildId: ''
    },
    cloudBuildOptions: {
      appYamlPath: '',
      cloudBuildTimeout: ''
    },
    container: {
      image: ''
    },
    files: {},
    zip: {
      filesCount: 0,
      sourceUrl: ''
    }
  },
  diskUsageBytes: '',
  endpointsApiService: {
    configId: '',
    disableTraceSampling: false,
    name: '',
    rolloutStrategy: ''
  },
  entrypoint: {
    shell: ''
  },
  env: '',
  envVariables: {},
  errorHandlers: [
    {
      errorCode: '',
      mimeType: '',
      staticFile: ''
    }
  ],
  flexibleRuntimeSettings: {
    operatingSystem: '',
    runtimeVersion: ''
  },
  handlers: [
    {
      apiEndpoint: {
        scriptPath: ''
      },
      authFailAction: '',
      login: '',
      redirectHttpResponseCode: '',
      script: {
        scriptPath: ''
      },
      securityLevel: '',
      staticFiles: {
        applicationReadable: false,
        expiration: '',
        httpHeaders: {},
        mimeType: '',
        path: '',
        requireMatchingFile: false,
        uploadPathRegex: ''
      },
      urlRegex: ''
    }
  ],
  healthCheck: {
    checkInterval: '',
    disableHealthCheck: false,
    healthyThreshold: 0,
    host: '',
    restartThreshold: 0,
    timeout: '',
    unhealthyThreshold: 0
  },
  id: '',
  inboundServices: [],
  instanceClass: '',
  libraries: [
    {
      name: '',
      version: ''
    }
  ],
  livenessCheck: {
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    initialDelay: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  manualScaling: {
    instances: 0
  },
  name: '',
  network: {
    forwardedPorts: [],
    instanceIpMode: '',
    instanceTag: '',
    name: '',
    sessionAffinity: false,
    subnetworkName: ''
  },
  nobuildFilesRegex: '',
  readinessCheck: {
    appStartTimeout: '',
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  resources: {
    cpu: '',
    diskGb: '',
    kmsKeyReference: '',
    memoryGb: '',
    volumes: [
      {
        name: '',
        sizeGb: '',
        volumeType: ''
      }
    ]
  },
  runtime: '',
  runtimeApiVersion: '',
  runtimeChannel: '',
  runtimeMainExecutablePath: '',
  serviceAccount: '',
  servingStatus: '',
  threadsafe: false,
  versionUrl: '',
  vm: false,
  vpcAccessConnector: {
    egressSetting: '',
    name: ''
  },
  zones: []
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId',
  headers: {'content-type': 'application/json'},
  data: {
    apiConfig: {authFailAction: '', login: '', script: '', securityLevel: '', url: ''},
    appEngineApis: false,
    automaticScaling: {
      coolDownPeriod: '',
      cpuUtilization: {aggregationWindowLength: '', targetUtilization: ''},
      customMetrics: [
        {
          filter: '',
          metricName: '',
          singleInstanceAssignment: '',
          targetType: '',
          targetUtilization: ''
        }
      ],
      diskUtilization: {
        targetReadBytesPerSecond: 0,
        targetReadOpsPerSecond: 0,
        targetWriteBytesPerSecond: 0,
        targetWriteOpsPerSecond: 0
      },
      maxConcurrentRequests: 0,
      maxIdleInstances: 0,
      maxPendingLatency: '',
      maxTotalInstances: 0,
      minIdleInstances: 0,
      minPendingLatency: '',
      minTotalInstances: 0,
      networkUtilization: {
        targetReceivedBytesPerSecond: 0,
        targetReceivedPacketsPerSecond: 0,
        targetSentBytesPerSecond: 0,
        targetSentPacketsPerSecond: 0
      },
      requestUtilization: {targetConcurrentRequests: 0, targetRequestCountPerSecond: 0},
      standardSchedulerSettings: {
        maxInstances: 0,
        minInstances: 0,
        targetCpuUtilization: '',
        targetThroughputUtilization: ''
      }
    },
    basicScaling: {idleTimeout: '', maxInstances: 0},
    betaSettings: {},
    buildEnvVariables: {},
    createTime: '',
    createdBy: '',
    defaultExpiration: '',
    deployment: {
      build: {cloudBuildId: ''},
      cloudBuildOptions: {appYamlPath: '', cloudBuildTimeout: ''},
      container: {image: ''},
      files: {},
      zip: {filesCount: 0, sourceUrl: ''}
    },
    diskUsageBytes: '',
    endpointsApiService: {configId: '', disableTraceSampling: false, name: '', rolloutStrategy: ''},
    entrypoint: {shell: ''},
    env: '',
    envVariables: {},
    errorHandlers: [{errorCode: '', mimeType: '', staticFile: ''}],
    flexibleRuntimeSettings: {operatingSystem: '', runtimeVersion: ''},
    handlers: [
      {
        apiEndpoint: {scriptPath: ''},
        authFailAction: '',
        login: '',
        redirectHttpResponseCode: '',
        script: {scriptPath: ''},
        securityLevel: '',
        staticFiles: {
          applicationReadable: false,
          expiration: '',
          httpHeaders: {},
          mimeType: '',
          path: '',
          requireMatchingFile: false,
          uploadPathRegex: ''
        },
        urlRegex: ''
      }
    ],
    healthCheck: {
      checkInterval: '',
      disableHealthCheck: false,
      healthyThreshold: 0,
      host: '',
      restartThreshold: 0,
      timeout: '',
      unhealthyThreshold: 0
    },
    id: '',
    inboundServices: [],
    instanceClass: '',
    libraries: [{name: '', version: ''}],
    livenessCheck: {
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      initialDelay: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    manualScaling: {instances: 0},
    name: '',
    network: {
      forwardedPorts: [],
      instanceIpMode: '',
      instanceTag: '',
      name: '',
      sessionAffinity: false,
      subnetworkName: ''
    },
    nobuildFilesRegex: '',
    readinessCheck: {
      appStartTimeout: '',
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    resources: {
      cpu: '',
      diskGb: '',
      kmsKeyReference: '',
      memoryGb: '',
      volumes: [{name: '', sizeGb: '', volumeType: ''}]
    },
    runtime: '',
    runtimeApiVersion: '',
    runtimeChannel: '',
    runtimeMainExecutablePath: '',
    serviceAccount: '',
    servingStatus: '',
    threadsafe: false,
    versionUrl: '',
    vm: false,
    vpcAccessConnector: {egressSetting: '', name: ''},
    zones: []
  }
};

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"apiConfig":{"authFailAction":"","login":"","script":"","securityLevel":"","url":""},"appEngineApis":false,"automaticScaling":{"coolDownPeriod":"","cpuUtilization":{"aggregationWindowLength":"","targetUtilization":""},"customMetrics":[{"filter":"","metricName":"","singleInstanceAssignment":"","targetType":"","targetUtilization":""}],"diskUtilization":{"targetReadBytesPerSecond":0,"targetReadOpsPerSecond":0,"targetWriteBytesPerSecond":0,"targetWriteOpsPerSecond":0},"maxConcurrentRequests":0,"maxIdleInstances":0,"maxPendingLatency":"","maxTotalInstances":0,"minIdleInstances":0,"minPendingLatency":"","minTotalInstances":0,"networkUtilization":{"targetReceivedBytesPerSecond":0,"targetReceivedPacketsPerSecond":0,"targetSentBytesPerSecond":0,"targetSentPacketsPerSecond":0},"requestUtilization":{"targetConcurrentRequests":0,"targetRequestCountPerSecond":0},"standardSchedulerSettings":{"maxInstances":0,"minInstances":0,"targetCpuUtilization":"","targetThroughputUtilization":""}},"basicScaling":{"idleTimeout":"","maxInstances":0},"betaSettings":{},"buildEnvVariables":{},"createTime":"","createdBy":"","defaultExpiration":"","deployment":{"build":{"cloudBuildId":""},"cloudBuildOptions":{"appYamlPath":"","cloudBuildTimeout":""},"container":{"image":""},"files":{},"zip":{"filesCount":0,"sourceUrl":""}},"diskUsageBytes":"","endpointsApiService":{"configId":"","disableTraceSampling":false,"name":"","rolloutStrategy":""},"entrypoint":{"shell":""},"env":"","envVariables":{},"errorHandlers":[{"errorCode":"","mimeType":"","staticFile":""}],"flexibleRuntimeSettings":{"operatingSystem":"","runtimeVersion":""},"handlers":[{"apiEndpoint":{"scriptPath":""},"authFailAction":"","login":"","redirectHttpResponseCode":"","script":{"scriptPath":""},"securityLevel":"","staticFiles":{"applicationReadable":false,"expiration":"","httpHeaders":{},"mimeType":"","path":"","requireMatchingFile":false,"uploadPathRegex":""},"urlRegex":""}],"healthCheck":{"checkInterval":"","disableHealthCheck":false,"healthyThreshold":0,"host":"","restartThreshold":0,"timeout":"","unhealthyThreshold":0},"id":"","inboundServices":[],"instanceClass":"","libraries":[{"name":"","version":""}],"livenessCheck":{"checkInterval":"","failureThreshold":0,"host":"","initialDelay":"","path":"","successThreshold":0,"timeout":""},"manualScaling":{"instances":0},"name":"","network":{"forwardedPorts":[],"instanceIpMode":"","instanceTag":"","name":"","sessionAffinity":false,"subnetworkName":""},"nobuildFilesRegex":"","readinessCheck":{"appStartTimeout":"","checkInterval":"","failureThreshold":0,"host":"","path":"","successThreshold":0,"timeout":""},"resources":{"cpu":"","diskGb":"","kmsKeyReference":"","memoryGb":"","volumes":[{"name":"","sizeGb":"","volumeType":""}]},"runtime":"","runtimeApiVersion":"","runtimeChannel":"","runtimeMainExecutablePath":"","serviceAccount":"","servingStatus":"","threadsafe":false,"versionUrl":"","vm":false,"vpcAccessConnector":{"egressSetting":"","name":""},"zones":[]}'
};

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "apiConfig": {\n    "authFailAction": "",\n    "login": "",\n    "script": "",\n    "securityLevel": "",\n    "url": ""\n  },\n  "appEngineApis": false,\n  "automaticScaling": {\n    "coolDownPeriod": "",\n    "cpuUtilization": {\n      "aggregationWindowLength": "",\n      "targetUtilization": ""\n    },\n    "customMetrics": [\n      {\n        "filter": "",\n        "metricName": "",\n        "singleInstanceAssignment": "",\n        "targetType": "",\n        "targetUtilization": ""\n      }\n    ],\n    "diskUtilization": {\n      "targetReadBytesPerSecond": 0,\n      "targetReadOpsPerSecond": 0,\n      "targetWriteBytesPerSecond": 0,\n      "targetWriteOpsPerSecond": 0\n    },\n    "maxConcurrentRequests": 0,\n    "maxIdleInstances": 0,\n    "maxPendingLatency": "",\n    "maxTotalInstances": 0,\n    "minIdleInstances": 0,\n    "minPendingLatency": "",\n    "minTotalInstances": 0,\n    "networkUtilization": {\n      "targetReceivedBytesPerSecond": 0,\n      "targetReceivedPacketsPerSecond": 0,\n      "targetSentBytesPerSecond": 0,\n      "targetSentPacketsPerSecond": 0\n    },\n    "requestUtilization": {\n      "targetConcurrentRequests": 0,\n      "targetRequestCountPerSecond": 0\n    },\n    "standardSchedulerSettings": {\n      "maxInstances": 0,\n      "minInstances": 0,\n      "targetCpuUtilization": "",\n      "targetThroughputUtilization": ""\n    }\n  },\n  "basicScaling": {\n    "idleTimeout": "",\n    "maxInstances": 0\n  },\n  "betaSettings": {},\n  "buildEnvVariables": {},\n  "createTime": "",\n  "createdBy": "",\n  "defaultExpiration": "",\n  "deployment": {\n    "build": {\n      "cloudBuildId": ""\n    },\n    "cloudBuildOptions": {\n      "appYamlPath": "",\n      "cloudBuildTimeout": ""\n    },\n    "container": {\n      "image": ""\n    },\n    "files": {},\n    "zip": {\n      "filesCount": 0,\n      "sourceUrl": ""\n    }\n  },\n  "diskUsageBytes": "",\n  "endpointsApiService": {\n    "configId": "",\n    "disableTraceSampling": false,\n    "name": "",\n    "rolloutStrategy": ""\n  },\n  "entrypoint": {\n    "shell": ""\n  },\n  "env": "",\n  "envVariables": {},\n  "errorHandlers": [\n    {\n      "errorCode": "",\n      "mimeType": "",\n      "staticFile": ""\n    }\n  ],\n  "flexibleRuntimeSettings": {\n    "operatingSystem": "",\n    "runtimeVersion": ""\n  },\n  "handlers": [\n    {\n      "apiEndpoint": {\n        "scriptPath": ""\n      },\n      "authFailAction": "",\n      "login": "",\n      "redirectHttpResponseCode": "",\n      "script": {\n        "scriptPath": ""\n      },\n      "securityLevel": "",\n      "staticFiles": {\n        "applicationReadable": false,\n        "expiration": "",\n        "httpHeaders": {},\n        "mimeType": "",\n        "path": "",\n        "requireMatchingFile": false,\n        "uploadPathRegex": ""\n      },\n      "urlRegex": ""\n    }\n  ],\n  "healthCheck": {\n    "checkInterval": "",\n    "disableHealthCheck": false,\n    "healthyThreshold": 0,\n    "host": "",\n    "restartThreshold": 0,\n    "timeout": "",\n    "unhealthyThreshold": 0\n  },\n  "id": "",\n  "inboundServices": [],\n  "instanceClass": "",\n  "libraries": [\n    {\n      "name": "",\n      "version": ""\n    }\n  ],\n  "livenessCheck": {\n    "checkInterval": "",\n    "failureThreshold": 0,\n    "host": "",\n    "initialDelay": "",\n    "path": "",\n    "successThreshold": 0,\n    "timeout": ""\n  },\n  "manualScaling": {\n    "instances": 0\n  },\n  "name": "",\n  "network": {\n    "forwardedPorts": [],\n    "instanceIpMode": "",\n    "instanceTag": "",\n    "name": "",\n    "sessionAffinity": false,\n    "subnetworkName": ""\n  },\n  "nobuildFilesRegex": "",\n  "readinessCheck": {\n    "appStartTimeout": "",\n    "checkInterval": "",\n    "failureThreshold": 0,\n    "host": "",\n    "path": "",\n    "successThreshold": 0,\n    "timeout": ""\n  },\n  "resources": {\n    "cpu": "",\n    "diskGb": "",\n    "kmsKeyReference": "",\n    "memoryGb": "",\n    "volumes": [\n      {\n        "name": "",\n        "sizeGb": "",\n        "volumeType": ""\n      }\n    ]\n  },\n  "runtime": "",\n  "runtimeApiVersion": "",\n  "runtimeChannel": "",\n  "runtimeMainExecutablePath": "",\n  "serviceAccount": "",\n  "servingStatus": "",\n  "threadsafe": false,\n  "versionUrl": "",\n  "vm": false,\n  "vpcAccessConnector": {\n    "egressSetting": "",\n    "name": ""\n  },\n  "zones": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")
  .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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId',
  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({
  apiConfig: {authFailAction: '', login: '', script: '', securityLevel: '', url: ''},
  appEngineApis: false,
  automaticScaling: {
    coolDownPeriod: '',
    cpuUtilization: {aggregationWindowLength: '', targetUtilization: ''},
    customMetrics: [
      {
        filter: '',
        metricName: '',
        singleInstanceAssignment: '',
        targetType: '',
        targetUtilization: ''
      }
    ],
    diskUtilization: {
      targetReadBytesPerSecond: 0,
      targetReadOpsPerSecond: 0,
      targetWriteBytesPerSecond: 0,
      targetWriteOpsPerSecond: 0
    },
    maxConcurrentRequests: 0,
    maxIdleInstances: 0,
    maxPendingLatency: '',
    maxTotalInstances: 0,
    minIdleInstances: 0,
    minPendingLatency: '',
    minTotalInstances: 0,
    networkUtilization: {
      targetReceivedBytesPerSecond: 0,
      targetReceivedPacketsPerSecond: 0,
      targetSentBytesPerSecond: 0,
      targetSentPacketsPerSecond: 0
    },
    requestUtilization: {targetConcurrentRequests: 0, targetRequestCountPerSecond: 0},
    standardSchedulerSettings: {
      maxInstances: 0,
      minInstances: 0,
      targetCpuUtilization: '',
      targetThroughputUtilization: ''
    }
  },
  basicScaling: {idleTimeout: '', maxInstances: 0},
  betaSettings: {},
  buildEnvVariables: {},
  createTime: '',
  createdBy: '',
  defaultExpiration: '',
  deployment: {
    build: {cloudBuildId: ''},
    cloudBuildOptions: {appYamlPath: '', cloudBuildTimeout: ''},
    container: {image: ''},
    files: {},
    zip: {filesCount: 0, sourceUrl: ''}
  },
  diskUsageBytes: '',
  endpointsApiService: {configId: '', disableTraceSampling: false, name: '', rolloutStrategy: ''},
  entrypoint: {shell: ''},
  env: '',
  envVariables: {},
  errorHandlers: [{errorCode: '', mimeType: '', staticFile: ''}],
  flexibleRuntimeSettings: {operatingSystem: '', runtimeVersion: ''},
  handlers: [
    {
      apiEndpoint: {scriptPath: ''},
      authFailAction: '',
      login: '',
      redirectHttpResponseCode: '',
      script: {scriptPath: ''},
      securityLevel: '',
      staticFiles: {
        applicationReadable: false,
        expiration: '',
        httpHeaders: {},
        mimeType: '',
        path: '',
        requireMatchingFile: false,
        uploadPathRegex: ''
      },
      urlRegex: ''
    }
  ],
  healthCheck: {
    checkInterval: '',
    disableHealthCheck: false,
    healthyThreshold: 0,
    host: '',
    restartThreshold: 0,
    timeout: '',
    unhealthyThreshold: 0
  },
  id: '',
  inboundServices: [],
  instanceClass: '',
  libraries: [{name: '', version: ''}],
  livenessCheck: {
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    initialDelay: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  manualScaling: {instances: 0},
  name: '',
  network: {
    forwardedPorts: [],
    instanceIpMode: '',
    instanceTag: '',
    name: '',
    sessionAffinity: false,
    subnetworkName: ''
  },
  nobuildFilesRegex: '',
  readinessCheck: {
    appStartTimeout: '',
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  resources: {
    cpu: '',
    diskGb: '',
    kmsKeyReference: '',
    memoryGb: '',
    volumes: [{name: '', sizeGb: '', volumeType: ''}]
  },
  runtime: '',
  runtimeApiVersion: '',
  runtimeChannel: '',
  runtimeMainExecutablePath: '',
  serviceAccount: '',
  servingStatus: '',
  threadsafe: false,
  versionUrl: '',
  vm: false,
  vpcAccessConnector: {egressSetting: '', name: ''},
  zones: []
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId',
  headers: {'content-type': 'application/json'},
  body: {
    apiConfig: {authFailAction: '', login: '', script: '', securityLevel: '', url: ''},
    appEngineApis: false,
    automaticScaling: {
      coolDownPeriod: '',
      cpuUtilization: {aggregationWindowLength: '', targetUtilization: ''},
      customMetrics: [
        {
          filter: '',
          metricName: '',
          singleInstanceAssignment: '',
          targetType: '',
          targetUtilization: ''
        }
      ],
      diskUtilization: {
        targetReadBytesPerSecond: 0,
        targetReadOpsPerSecond: 0,
        targetWriteBytesPerSecond: 0,
        targetWriteOpsPerSecond: 0
      },
      maxConcurrentRequests: 0,
      maxIdleInstances: 0,
      maxPendingLatency: '',
      maxTotalInstances: 0,
      minIdleInstances: 0,
      minPendingLatency: '',
      minTotalInstances: 0,
      networkUtilization: {
        targetReceivedBytesPerSecond: 0,
        targetReceivedPacketsPerSecond: 0,
        targetSentBytesPerSecond: 0,
        targetSentPacketsPerSecond: 0
      },
      requestUtilization: {targetConcurrentRequests: 0, targetRequestCountPerSecond: 0},
      standardSchedulerSettings: {
        maxInstances: 0,
        minInstances: 0,
        targetCpuUtilization: '',
        targetThroughputUtilization: ''
      }
    },
    basicScaling: {idleTimeout: '', maxInstances: 0},
    betaSettings: {},
    buildEnvVariables: {},
    createTime: '',
    createdBy: '',
    defaultExpiration: '',
    deployment: {
      build: {cloudBuildId: ''},
      cloudBuildOptions: {appYamlPath: '', cloudBuildTimeout: ''},
      container: {image: ''},
      files: {},
      zip: {filesCount: 0, sourceUrl: ''}
    },
    diskUsageBytes: '',
    endpointsApiService: {configId: '', disableTraceSampling: false, name: '', rolloutStrategy: ''},
    entrypoint: {shell: ''},
    env: '',
    envVariables: {},
    errorHandlers: [{errorCode: '', mimeType: '', staticFile: ''}],
    flexibleRuntimeSettings: {operatingSystem: '', runtimeVersion: ''},
    handlers: [
      {
        apiEndpoint: {scriptPath: ''},
        authFailAction: '',
        login: '',
        redirectHttpResponseCode: '',
        script: {scriptPath: ''},
        securityLevel: '',
        staticFiles: {
          applicationReadable: false,
          expiration: '',
          httpHeaders: {},
          mimeType: '',
          path: '',
          requireMatchingFile: false,
          uploadPathRegex: ''
        },
        urlRegex: ''
      }
    ],
    healthCheck: {
      checkInterval: '',
      disableHealthCheck: false,
      healthyThreshold: 0,
      host: '',
      restartThreshold: 0,
      timeout: '',
      unhealthyThreshold: 0
    },
    id: '',
    inboundServices: [],
    instanceClass: '',
    libraries: [{name: '', version: ''}],
    livenessCheck: {
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      initialDelay: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    manualScaling: {instances: 0},
    name: '',
    network: {
      forwardedPorts: [],
      instanceIpMode: '',
      instanceTag: '',
      name: '',
      sessionAffinity: false,
      subnetworkName: ''
    },
    nobuildFilesRegex: '',
    readinessCheck: {
      appStartTimeout: '',
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    resources: {
      cpu: '',
      diskGb: '',
      kmsKeyReference: '',
      memoryGb: '',
      volumes: [{name: '', sizeGb: '', volumeType: ''}]
    },
    runtime: '',
    runtimeApiVersion: '',
    runtimeChannel: '',
    runtimeMainExecutablePath: '',
    serviceAccount: '',
    servingStatus: '',
    threadsafe: false,
    versionUrl: '',
    vm: false,
    vpcAccessConnector: {egressSetting: '', name: ''},
    zones: []
  },
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');

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

req.type('json');
req.send({
  apiConfig: {
    authFailAction: '',
    login: '',
    script: '',
    securityLevel: '',
    url: ''
  },
  appEngineApis: false,
  automaticScaling: {
    coolDownPeriod: '',
    cpuUtilization: {
      aggregationWindowLength: '',
      targetUtilization: ''
    },
    customMetrics: [
      {
        filter: '',
        metricName: '',
        singleInstanceAssignment: '',
        targetType: '',
        targetUtilization: ''
      }
    ],
    diskUtilization: {
      targetReadBytesPerSecond: 0,
      targetReadOpsPerSecond: 0,
      targetWriteBytesPerSecond: 0,
      targetWriteOpsPerSecond: 0
    },
    maxConcurrentRequests: 0,
    maxIdleInstances: 0,
    maxPendingLatency: '',
    maxTotalInstances: 0,
    minIdleInstances: 0,
    minPendingLatency: '',
    minTotalInstances: 0,
    networkUtilization: {
      targetReceivedBytesPerSecond: 0,
      targetReceivedPacketsPerSecond: 0,
      targetSentBytesPerSecond: 0,
      targetSentPacketsPerSecond: 0
    },
    requestUtilization: {
      targetConcurrentRequests: 0,
      targetRequestCountPerSecond: 0
    },
    standardSchedulerSettings: {
      maxInstances: 0,
      minInstances: 0,
      targetCpuUtilization: '',
      targetThroughputUtilization: ''
    }
  },
  basicScaling: {
    idleTimeout: '',
    maxInstances: 0
  },
  betaSettings: {},
  buildEnvVariables: {},
  createTime: '',
  createdBy: '',
  defaultExpiration: '',
  deployment: {
    build: {
      cloudBuildId: ''
    },
    cloudBuildOptions: {
      appYamlPath: '',
      cloudBuildTimeout: ''
    },
    container: {
      image: ''
    },
    files: {},
    zip: {
      filesCount: 0,
      sourceUrl: ''
    }
  },
  diskUsageBytes: '',
  endpointsApiService: {
    configId: '',
    disableTraceSampling: false,
    name: '',
    rolloutStrategy: ''
  },
  entrypoint: {
    shell: ''
  },
  env: '',
  envVariables: {},
  errorHandlers: [
    {
      errorCode: '',
      mimeType: '',
      staticFile: ''
    }
  ],
  flexibleRuntimeSettings: {
    operatingSystem: '',
    runtimeVersion: ''
  },
  handlers: [
    {
      apiEndpoint: {
        scriptPath: ''
      },
      authFailAction: '',
      login: '',
      redirectHttpResponseCode: '',
      script: {
        scriptPath: ''
      },
      securityLevel: '',
      staticFiles: {
        applicationReadable: false,
        expiration: '',
        httpHeaders: {},
        mimeType: '',
        path: '',
        requireMatchingFile: false,
        uploadPathRegex: ''
      },
      urlRegex: ''
    }
  ],
  healthCheck: {
    checkInterval: '',
    disableHealthCheck: false,
    healthyThreshold: 0,
    host: '',
    restartThreshold: 0,
    timeout: '',
    unhealthyThreshold: 0
  },
  id: '',
  inboundServices: [],
  instanceClass: '',
  libraries: [
    {
      name: '',
      version: ''
    }
  ],
  livenessCheck: {
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    initialDelay: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  manualScaling: {
    instances: 0
  },
  name: '',
  network: {
    forwardedPorts: [],
    instanceIpMode: '',
    instanceTag: '',
    name: '',
    sessionAffinity: false,
    subnetworkName: ''
  },
  nobuildFilesRegex: '',
  readinessCheck: {
    appStartTimeout: '',
    checkInterval: '',
    failureThreshold: 0,
    host: '',
    path: '',
    successThreshold: 0,
    timeout: ''
  },
  resources: {
    cpu: '',
    diskGb: '',
    kmsKeyReference: '',
    memoryGb: '',
    volumes: [
      {
        name: '',
        sizeGb: '',
        volumeType: ''
      }
    ]
  },
  runtime: '',
  runtimeApiVersion: '',
  runtimeChannel: '',
  runtimeMainExecutablePath: '',
  serviceAccount: '',
  servingStatus: '',
  threadsafe: false,
  versionUrl: '',
  vm: false,
  vpcAccessConnector: {
    egressSetting: '',
    name: ''
  },
  zones: []
});

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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId',
  headers: {'content-type': 'application/json'},
  data: {
    apiConfig: {authFailAction: '', login: '', script: '', securityLevel: '', url: ''},
    appEngineApis: false,
    automaticScaling: {
      coolDownPeriod: '',
      cpuUtilization: {aggregationWindowLength: '', targetUtilization: ''},
      customMetrics: [
        {
          filter: '',
          metricName: '',
          singleInstanceAssignment: '',
          targetType: '',
          targetUtilization: ''
        }
      ],
      diskUtilization: {
        targetReadBytesPerSecond: 0,
        targetReadOpsPerSecond: 0,
        targetWriteBytesPerSecond: 0,
        targetWriteOpsPerSecond: 0
      },
      maxConcurrentRequests: 0,
      maxIdleInstances: 0,
      maxPendingLatency: '',
      maxTotalInstances: 0,
      minIdleInstances: 0,
      minPendingLatency: '',
      minTotalInstances: 0,
      networkUtilization: {
        targetReceivedBytesPerSecond: 0,
        targetReceivedPacketsPerSecond: 0,
        targetSentBytesPerSecond: 0,
        targetSentPacketsPerSecond: 0
      },
      requestUtilization: {targetConcurrentRequests: 0, targetRequestCountPerSecond: 0},
      standardSchedulerSettings: {
        maxInstances: 0,
        minInstances: 0,
        targetCpuUtilization: '',
        targetThroughputUtilization: ''
      }
    },
    basicScaling: {idleTimeout: '', maxInstances: 0},
    betaSettings: {},
    buildEnvVariables: {},
    createTime: '',
    createdBy: '',
    defaultExpiration: '',
    deployment: {
      build: {cloudBuildId: ''},
      cloudBuildOptions: {appYamlPath: '', cloudBuildTimeout: ''},
      container: {image: ''},
      files: {},
      zip: {filesCount: 0, sourceUrl: ''}
    },
    diskUsageBytes: '',
    endpointsApiService: {configId: '', disableTraceSampling: false, name: '', rolloutStrategy: ''},
    entrypoint: {shell: ''},
    env: '',
    envVariables: {},
    errorHandlers: [{errorCode: '', mimeType: '', staticFile: ''}],
    flexibleRuntimeSettings: {operatingSystem: '', runtimeVersion: ''},
    handlers: [
      {
        apiEndpoint: {scriptPath: ''},
        authFailAction: '',
        login: '',
        redirectHttpResponseCode: '',
        script: {scriptPath: ''},
        securityLevel: '',
        staticFiles: {
          applicationReadable: false,
          expiration: '',
          httpHeaders: {},
          mimeType: '',
          path: '',
          requireMatchingFile: false,
          uploadPathRegex: ''
        },
        urlRegex: ''
      }
    ],
    healthCheck: {
      checkInterval: '',
      disableHealthCheck: false,
      healthyThreshold: 0,
      host: '',
      restartThreshold: 0,
      timeout: '',
      unhealthyThreshold: 0
    },
    id: '',
    inboundServices: [],
    instanceClass: '',
    libraries: [{name: '', version: ''}],
    livenessCheck: {
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      initialDelay: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    manualScaling: {instances: 0},
    name: '',
    network: {
      forwardedPorts: [],
      instanceIpMode: '',
      instanceTag: '',
      name: '',
      sessionAffinity: false,
      subnetworkName: ''
    },
    nobuildFilesRegex: '',
    readinessCheck: {
      appStartTimeout: '',
      checkInterval: '',
      failureThreshold: 0,
      host: '',
      path: '',
      successThreshold: 0,
      timeout: ''
    },
    resources: {
      cpu: '',
      diskGb: '',
      kmsKeyReference: '',
      memoryGb: '',
      volumes: [{name: '', sizeGb: '', volumeType: ''}]
    },
    runtime: '',
    runtimeApiVersion: '',
    runtimeChannel: '',
    runtimeMainExecutablePath: '',
    serviceAccount: '',
    servingStatus: '',
    threadsafe: false,
    versionUrl: '',
    vm: false,
    vpcAccessConnector: {egressSetting: '', name: ''},
    zones: []
  }
};

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

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

const url = '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"apiConfig":{"authFailAction":"","login":"","script":"","securityLevel":"","url":""},"appEngineApis":false,"automaticScaling":{"coolDownPeriod":"","cpuUtilization":{"aggregationWindowLength":"","targetUtilization":""},"customMetrics":[{"filter":"","metricName":"","singleInstanceAssignment":"","targetType":"","targetUtilization":""}],"diskUtilization":{"targetReadBytesPerSecond":0,"targetReadOpsPerSecond":0,"targetWriteBytesPerSecond":0,"targetWriteOpsPerSecond":0},"maxConcurrentRequests":0,"maxIdleInstances":0,"maxPendingLatency":"","maxTotalInstances":0,"minIdleInstances":0,"minPendingLatency":"","minTotalInstances":0,"networkUtilization":{"targetReceivedBytesPerSecond":0,"targetReceivedPacketsPerSecond":0,"targetSentBytesPerSecond":0,"targetSentPacketsPerSecond":0},"requestUtilization":{"targetConcurrentRequests":0,"targetRequestCountPerSecond":0},"standardSchedulerSettings":{"maxInstances":0,"minInstances":0,"targetCpuUtilization":"","targetThroughputUtilization":""}},"basicScaling":{"idleTimeout":"","maxInstances":0},"betaSettings":{},"buildEnvVariables":{},"createTime":"","createdBy":"","defaultExpiration":"","deployment":{"build":{"cloudBuildId":""},"cloudBuildOptions":{"appYamlPath":"","cloudBuildTimeout":""},"container":{"image":""},"files":{},"zip":{"filesCount":0,"sourceUrl":""}},"diskUsageBytes":"","endpointsApiService":{"configId":"","disableTraceSampling":false,"name":"","rolloutStrategy":""},"entrypoint":{"shell":""},"env":"","envVariables":{},"errorHandlers":[{"errorCode":"","mimeType":"","staticFile":""}],"flexibleRuntimeSettings":{"operatingSystem":"","runtimeVersion":""},"handlers":[{"apiEndpoint":{"scriptPath":""},"authFailAction":"","login":"","redirectHttpResponseCode":"","script":{"scriptPath":""},"securityLevel":"","staticFiles":{"applicationReadable":false,"expiration":"","httpHeaders":{},"mimeType":"","path":"","requireMatchingFile":false,"uploadPathRegex":""},"urlRegex":""}],"healthCheck":{"checkInterval":"","disableHealthCheck":false,"healthyThreshold":0,"host":"","restartThreshold":0,"timeout":"","unhealthyThreshold":0},"id":"","inboundServices":[],"instanceClass":"","libraries":[{"name":"","version":""}],"livenessCheck":{"checkInterval":"","failureThreshold":0,"host":"","initialDelay":"","path":"","successThreshold":0,"timeout":""},"manualScaling":{"instances":0},"name":"","network":{"forwardedPorts":[],"instanceIpMode":"","instanceTag":"","name":"","sessionAffinity":false,"subnetworkName":""},"nobuildFilesRegex":"","readinessCheck":{"appStartTimeout":"","checkInterval":"","failureThreshold":0,"host":"","path":"","successThreshold":0,"timeout":""},"resources":{"cpu":"","diskGb":"","kmsKeyReference":"","memoryGb":"","volumes":[{"name":"","sizeGb":"","volumeType":""}]},"runtime":"","runtimeApiVersion":"","runtimeChannel":"","runtimeMainExecutablePath":"","serviceAccount":"","servingStatus":"","threadsafe":false,"versionUrl":"","vm":false,"vpcAccessConnector":{"egressSetting":"","name":""},"zones":[]}'
};

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 = @{ @"apiConfig": @{ @"authFailAction": @"", @"login": @"", @"script": @"", @"securityLevel": @"", @"url": @"" },
                              @"appEngineApis": @NO,
                              @"automaticScaling": @{ @"coolDownPeriod": @"", @"cpuUtilization": @{ @"aggregationWindowLength": @"", @"targetUtilization": @"" }, @"customMetrics": @[ @{ @"filter": @"", @"metricName": @"", @"singleInstanceAssignment": @"", @"targetType": @"", @"targetUtilization": @"" } ], @"diskUtilization": @{ @"targetReadBytesPerSecond": @0, @"targetReadOpsPerSecond": @0, @"targetWriteBytesPerSecond": @0, @"targetWriteOpsPerSecond": @0 }, @"maxConcurrentRequests": @0, @"maxIdleInstances": @0, @"maxPendingLatency": @"", @"maxTotalInstances": @0, @"minIdleInstances": @0, @"minPendingLatency": @"", @"minTotalInstances": @0, @"networkUtilization": @{ @"targetReceivedBytesPerSecond": @0, @"targetReceivedPacketsPerSecond": @0, @"targetSentBytesPerSecond": @0, @"targetSentPacketsPerSecond": @0 }, @"requestUtilization": @{ @"targetConcurrentRequests": @0, @"targetRequestCountPerSecond": @0 }, @"standardSchedulerSettings": @{ @"maxInstances": @0, @"minInstances": @0, @"targetCpuUtilization": @"", @"targetThroughputUtilization": @"" } },
                              @"basicScaling": @{ @"idleTimeout": @"", @"maxInstances": @0 },
                              @"betaSettings": @{  },
                              @"buildEnvVariables": @{  },
                              @"createTime": @"",
                              @"createdBy": @"",
                              @"defaultExpiration": @"",
                              @"deployment": @{ @"build": @{ @"cloudBuildId": @"" }, @"cloudBuildOptions": @{ @"appYamlPath": @"", @"cloudBuildTimeout": @"" }, @"container": @{ @"image": @"" }, @"files": @{  }, @"zip": @{ @"filesCount": @0, @"sourceUrl": @"" } },
                              @"diskUsageBytes": @"",
                              @"endpointsApiService": @{ @"configId": @"", @"disableTraceSampling": @NO, @"name": @"", @"rolloutStrategy": @"" },
                              @"entrypoint": @{ @"shell": @"" },
                              @"env": @"",
                              @"envVariables": @{  },
                              @"errorHandlers": @[ @{ @"errorCode": @"", @"mimeType": @"", @"staticFile": @"" } ],
                              @"flexibleRuntimeSettings": @{ @"operatingSystem": @"", @"runtimeVersion": @"" },
                              @"handlers": @[ @{ @"apiEndpoint": @{ @"scriptPath": @"" }, @"authFailAction": @"", @"login": @"", @"redirectHttpResponseCode": @"", @"script": @{ @"scriptPath": @"" }, @"securityLevel": @"", @"staticFiles": @{ @"applicationReadable": @NO, @"expiration": @"", @"httpHeaders": @{  }, @"mimeType": @"", @"path": @"", @"requireMatchingFile": @NO, @"uploadPathRegex": @"" }, @"urlRegex": @"" } ],
                              @"healthCheck": @{ @"checkInterval": @"", @"disableHealthCheck": @NO, @"healthyThreshold": @0, @"host": @"", @"restartThreshold": @0, @"timeout": @"", @"unhealthyThreshold": @0 },
                              @"id": @"",
                              @"inboundServices": @[  ],
                              @"instanceClass": @"",
                              @"libraries": @[ @{ @"name": @"", @"version": @"" } ],
                              @"livenessCheck": @{ @"checkInterval": @"", @"failureThreshold": @0, @"host": @"", @"initialDelay": @"", @"path": @"", @"successThreshold": @0, @"timeout": @"" },
                              @"manualScaling": @{ @"instances": @0 },
                              @"name": @"",
                              @"network": @{ @"forwardedPorts": @[  ], @"instanceIpMode": @"", @"instanceTag": @"", @"name": @"", @"sessionAffinity": @NO, @"subnetworkName": @"" },
                              @"nobuildFilesRegex": @"",
                              @"readinessCheck": @{ @"appStartTimeout": @"", @"checkInterval": @"", @"failureThreshold": @0, @"host": @"", @"path": @"", @"successThreshold": @0, @"timeout": @"" },
                              @"resources": @{ @"cpu": @"", @"diskGb": @"", @"kmsKeyReference": @"", @"memoryGb": @"", @"volumes": @[ @{ @"name": @"", @"sizeGb": @"", @"volumeType": @"" } ] },
                              @"runtime": @"",
                              @"runtimeApiVersion": @"",
                              @"runtimeChannel": @"",
                              @"runtimeMainExecutablePath": @"",
                              @"serviceAccount": @"",
                              @"servingStatus": @"",
                              @"threadsafe": @NO,
                              @"versionUrl": @"",
                              @"vm": @NO,
                              @"vpcAccessConnector": @{ @"egressSetting": @"", @"name": @"" },
                              @"zones": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"]
                                                       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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}" in

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

 "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId",
  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([
    'apiConfig' => [
        'authFailAction' => '',
        'login' => '',
        'script' => '',
        'securityLevel' => '',
        'url' => ''
    ],
    'appEngineApis' => null,
    'automaticScaling' => [
        'coolDownPeriod' => '',
        'cpuUtilization' => [
                'aggregationWindowLength' => '',
                'targetUtilization' => ''
        ],
        'customMetrics' => [
                [
                                'filter' => '',
                                'metricName' => '',
                                'singleInstanceAssignment' => '',
                                'targetType' => '',
                                'targetUtilization' => ''
                ]
        ],
        'diskUtilization' => [
                'targetReadBytesPerSecond' => 0,
                'targetReadOpsPerSecond' => 0,
                'targetWriteBytesPerSecond' => 0,
                'targetWriteOpsPerSecond' => 0
        ],
        'maxConcurrentRequests' => 0,
        'maxIdleInstances' => 0,
        'maxPendingLatency' => '',
        'maxTotalInstances' => 0,
        'minIdleInstances' => 0,
        'minPendingLatency' => '',
        'minTotalInstances' => 0,
        'networkUtilization' => [
                'targetReceivedBytesPerSecond' => 0,
                'targetReceivedPacketsPerSecond' => 0,
                'targetSentBytesPerSecond' => 0,
                'targetSentPacketsPerSecond' => 0
        ],
        'requestUtilization' => [
                'targetConcurrentRequests' => 0,
                'targetRequestCountPerSecond' => 0
        ],
        'standardSchedulerSettings' => [
                'maxInstances' => 0,
                'minInstances' => 0,
                'targetCpuUtilization' => '',
                'targetThroughputUtilization' => ''
        ]
    ],
    'basicScaling' => [
        'idleTimeout' => '',
        'maxInstances' => 0
    ],
    'betaSettings' => [
        
    ],
    'buildEnvVariables' => [
        
    ],
    'createTime' => '',
    'createdBy' => '',
    'defaultExpiration' => '',
    'deployment' => [
        'build' => [
                'cloudBuildId' => ''
        ],
        'cloudBuildOptions' => [
                'appYamlPath' => '',
                'cloudBuildTimeout' => ''
        ],
        'container' => [
                'image' => ''
        ],
        'files' => [
                
        ],
        'zip' => [
                'filesCount' => 0,
                'sourceUrl' => ''
        ]
    ],
    'diskUsageBytes' => '',
    'endpointsApiService' => [
        'configId' => '',
        'disableTraceSampling' => null,
        'name' => '',
        'rolloutStrategy' => ''
    ],
    'entrypoint' => [
        'shell' => ''
    ],
    'env' => '',
    'envVariables' => [
        
    ],
    'errorHandlers' => [
        [
                'errorCode' => '',
                'mimeType' => '',
                'staticFile' => ''
        ]
    ],
    'flexibleRuntimeSettings' => [
        'operatingSystem' => '',
        'runtimeVersion' => ''
    ],
    'handlers' => [
        [
                'apiEndpoint' => [
                                'scriptPath' => ''
                ],
                'authFailAction' => '',
                'login' => '',
                'redirectHttpResponseCode' => '',
                'script' => [
                                'scriptPath' => ''
                ],
                'securityLevel' => '',
                'staticFiles' => [
                                'applicationReadable' => null,
                                'expiration' => '',
                                'httpHeaders' => [
                                                                
                                ],
                                'mimeType' => '',
                                'path' => '',
                                'requireMatchingFile' => null,
                                'uploadPathRegex' => ''
                ],
                'urlRegex' => ''
        ]
    ],
    'healthCheck' => [
        'checkInterval' => '',
        'disableHealthCheck' => null,
        'healthyThreshold' => 0,
        'host' => '',
        'restartThreshold' => 0,
        'timeout' => '',
        'unhealthyThreshold' => 0
    ],
    'id' => '',
    'inboundServices' => [
        
    ],
    'instanceClass' => '',
    'libraries' => [
        [
                'name' => '',
                'version' => ''
        ]
    ],
    'livenessCheck' => [
        'checkInterval' => '',
        'failureThreshold' => 0,
        'host' => '',
        'initialDelay' => '',
        'path' => '',
        'successThreshold' => 0,
        'timeout' => ''
    ],
    'manualScaling' => [
        'instances' => 0
    ],
    'name' => '',
    'network' => [
        'forwardedPorts' => [
                
        ],
        'instanceIpMode' => '',
        'instanceTag' => '',
        'name' => '',
        'sessionAffinity' => null,
        'subnetworkName' => ''
    ],
    'nobuildFilesRegex' => '',
    'readinessCheck' => [
        'appStartTimeout' => '',
        'checkInterval' => '',
        'failureThreshold' => 0,
        'host' => '',
        'path' => '',
        'successThreshold' => 0,
        'timeout' => ''
    ],
    'resources' => [
        'cpu' => '',
        'diskGb' => '',
        'kmsKeyReference' => '',
        'memoryGb' => '',
        'volumes' => [
                [
                                'name' => '',
                                'sizeGb' => '',
                                'volumeType' => ''
                ]
        ]
    ],
    'runtime' => '',
    'runtimeApiVersion' => '',
    'runtimeChannel' => '',
    'runtimeMainExecutablePath' => '',
    'serviceAccount' => '',
    'servingStatus' => '',
    'threadsafe' => null,
    'versionUrl' => '',
    'vm' => null,
    'vpcAccessConnector' => [
        'egressSetting' => '',
        'name' => ''
    ],
    'zones' => [
        
    ]
  ]),
  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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId', [
  'body' => '{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'apiConfig' => [
    'authFailAction' => '',
    'login' => '',
    'script' => '',
    'securityLevel' => '',
    'url' => ''
  ],
  'appEngineApis' => null,
  'automaticScaling' => [
    'coolDownPeriod' => '',
    'cpuUtilization' => [
        'aggregationWindowLength' => '',
        'targetUtilization' => ''
    ],
    'customMetrics' => [
        [
                'filter' => '',
                'metricName' => '',
                'singleInstanceAssignment' => '',
                'targetType' => '',
                'targetUtilization' => ''
        ]
    ],
    'diskUtilization' => [
        'targetReadBytesPerSecond' => 0,
        'targetReadOpsPerSecond' => 0,
        'targetWriteBytesPerSecond' => 0,
        'targetWriteOpsPerSecond' => 0
    ],
    'maxConcurrentRequests' => 0,
    'maxIdleInstances' => 0,
    'maxPendingLatency' => '',
    'maxTotalInstances' => 0,
    'minIdleInstances' => 0,
    'minPendingLatency' => '',
    'minTotalInstances' => 0,
    'networkUtilization' => [
        'targetReceivedBytesPerSecond' => 0,
        'targetReceivedPacketsPerSecond' => 0,
        'targetSentBytesPerSecond' => 0,
        'targetSentPacketsPerSecond' => 0
    ],
    'requestUtilization' => [
        'targetConcurrentRequests' => 0,
        'targetRequestCountPerSecond' => 0
    ],
    'standardSchedulerSettings' => [
        'maxInstances' => 0,
        'minInstances' => 0,
        'targetCpuUtilization' => '',
        'targetThroughputUtilization' => ''
    ]
  ],
  'basicScaling' => [
    'idleTimeout' => '',
    'maxInstances' => 0
  ],
  'betaSettings' => [
    
  ],
  'buildEnvVariables' => [
    
  ],
  'createTime' => '',
  'createdBy' => '',
  'defaultExpiration' => '',
  'deployment' => [
    'build' => [
        'cloudBuildId' => ''
    ],
    'cloudBuildOptions' => [
        'appYamlPath' => '',
        'cloudBuildTimeout' => ''
    ],
    'container' => [
        'image' => ''
    ],
    'files' => [
        
    ],
    'zip' => [
        'filesCount' => 0,
        'sourceUrl' => ''
    ]
  ],
  'diskUsageBytes' => '',
  'endpointsApiService' => [
    'configId' => '',
    'disableTraceSampling' => null,
    'name' => '',
    'rolloutStrategy' => ''
  ],
  'entrypoint' => [
    'shell' => ''
  ],
  'env' => '',
  'envVariables' => [
    
  ],
  'errorHandlers' => [
    [
        'errorCode' => '',
        'mimeType' => '',
        'staticFile' => ''
    ]
  ],
  'flexibleRuntimeSettings' => [
    'operatingSystem' => '',
    'runtimeVersion' => ''
  ],
  'handlers' => [
    [
        'apiEndpoint' => [
                'scriptPath' => ''
        ],
        'authFailAction' => '',
        'login' => '',
        'redirectHttpResponseCode' => '',
        'script' => [
                'scriptPath' => ''
        ],
        'securityLevel' => '',
        'staticFiles' => [
                'applicationReadable' => null,
                'expiration' => '',
                'httpHeaders' => [
                                
                ],
                'mimeType' => '',
                'path' => '',
                'requireMatchingFile' => null,
                'uploadPathRegex' => ''
        ],
        'urlRegex' => ''
    ]
  ],
  'healthCheck' => [
    'checkInterval' => '',
    'disableHealthCheck' => null,
    'healthyThreshold' => 0,
    'host' => '',
    'restartThreshold' => 0,
    'timeout' => '',
    'unhealthyThreshold' => 0
  ],
  'id' => '',
  'inboundServices' => [
    
  ],
  'instanceClass' => '',
  'libraries' => [
    [
        'name' => '',
        'version' => ''
    ]
  ],
  'livenessCheck' => [
    'checkInterval' => '',
    'failureThreshold' => 0,
    'host' => '',
    'initialDelay' => '',
    'path' => '',
    'successThreshold' => 0,
    'timeout' => ''
  ],
  'manualScaling' => [
    'instances' => 0
  ],
  'name' => '',
  'network' => [
    'forwardedPorts' => [
        
    ],
    'instanceIpMode' => '',
    'instanceTag' => '',
    'name' => '',
    'sessionAffinity' => null,
    'subnetworkName' => ''
  ],
  'nobuildFilesRegex' => '',
  'readinessCheck' => [
    'appStartTimeout' => '',
    'checkInterval' => '',
    'failureThreshold' => 0,
    'host' => '',
    'path' => '',
    'successThreshold' => 0,
    'timeout' => ''
  ],
  'resources' => [
    'cpu' => '',
    'diskGb' => '',
    'kmsKeyReference' => '',
    'memoryGb' => '',
    'volumes' => [
        [
                'name' => '',
                'sizeGb' => '',
                'volumeType' => ''
        ]
    ]
  ],
  'runtime' => '',
  'runtimeApiVersion' => '',
  'runtimeChannel' => '',
  'runtimeMainExecutablePath' => '',
  'serviceAccount' => '',
  'servingStatus' => '',
  'threadsafe' => null,
  'versionUrl' => '',
  'vm' => null,
  'vpcAccessConnector' => [
    'egressSetting' => '',
    'name' => ''
  ],
  'zones' => [
    
  ]
]));

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

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

append(json_encode([
  'apiConfig' => [
    'authFailAction' => '',
    'login' => '',
    'script' => '',
    'securityLevel' => '',
    'url' => ''
  ],
  'appEngineApis' => null,
  'automaticScaling' => [
    'coolDownPeriod' => '',
    'cpuUtilization' => [
        'aggregationWindowLength' => '',
        'targetUtilization' => ''
    ],
    'customMetrics' => [
        [
                'filter' => '',
                'metricName' => '',
                'singleInstanceAssignment' => '',
                'targetType' => '',
                'targetUtilization' => ''
        ]
    ],
    'diskUtilization' => [
        'targetReadBytesPerSecond' => 0,
        'targetReadOpsPerSecond' => 0,
        'targetWriteBytesPerSecond' => 0,
        'targetWriteOpsPerSecond' => 0
    ],
    'maxConcurrentRequests' => 0,
    'maxIdleInstances' => 0,
    'maxPendingLatency' => '',
    'maxTotalInstances' => 0,
    'minIdleInstances' => 0,
    'minPendingLatency' => '',
    'minTotalInstances' => 0,
    'networkUtilization' => [
        'targetReceivedBytesPerSecond' => 0,
        'targetReceivedPacketsPerSecond' => 0,
        'targetSentBytesPerSecond' => 0,
        'targetSentPacketsPerSecond' => 0
    ],
    'requestUtilization' => [
        'targetConcurrentRequests' => 0,
        'targetRequestCountPerSecond' => 0
    ],
    'standardSchedulerSettings' => [
        'maxInstances' => 0,
        'minInstances' => 0,
        'targetCpuUtilization' => '',
        'targetThroughputUtilization' => ''
    ]
  ],
  'basicScaling' => [
    'idleTimeout' => '',
    'maxInstances' => 0
  ],
  'betaSettings' => [
    
  ],
  'buildEnvVariables' => [
    
  ],
  'createTime' => '',
  'createdBy' => '',
  'defaultExpiration' => '',
  'deployment' => [
    'build' => [
        'cloudBuildId' => ''
    ],
    'cloudBuildOptions' => [
        'appYamlPath' => '',
        'cloudBuildTimeout' => ''
    ],
    'container' => [
        'image' => ''
    ],
    'files' => [
        
    ],
    'zip' => [
        'filesCount' => 0,
        'sourceUrl' => ''
    ]
  ],
  'diskUsageBytes' => '',
  'endpointsApiService' => [
    'configId' => '',
    'disableTraceSampling' => null,
    'name' => '',
    'rolloutStrategy' => ''
  ],
  'entrypoint' => [
    'shell' => ''
  ],
  'env' => '',
  'envVariables' => [
    
  ],
  'errorHandlers' => [
    [
        'errorCode' => '',
        'mimeType' => '',
        'staticFile' => ''
    ]
  ],
  'flexibleRuntimeSettings' => [
    'operatingSystem' => '',
    'runtimeVersion' => ''
  ],
  'handlers' => [
    [
        'apiEndpoint' => [
                'scriptPath' => ''
        ],
        'authFailAction' => '',
        'login' => '',
        'redirectHttpResponseCode' => '',
        'script' => [
                'scriptPath' => ''
        ],
        'securityLevel' => '',
        'staticFiles' => [
                'applicationReadable' => null,
                'expiration' => '',
                'httpHeaders' => [
                                
                ],
                'mimeType' => '',
                'path' => '',
                'requireMatchingFile' => null,
                'uploadPathRegex' => ''
        ],
        'urlRegex' => ''
    ]
  ],
  'healthCheck' => [
    'checkInterval' => '',
    'disableHealthCheck' => null,
    'healthyThreshold' => 0,
    'host' => '',
    'restartThreshold' => 0,
    'timeout' => '',
    'unhealthyThreshold' => 0
  ],
  'id' => '',
  'inboundServices' => [
    
  ],
  'instanceClass' => '',
  'libraries' => [
    [
        'name' => '',
        'version' => ''
    ]
  ],
  'livenessCheck' => [
    'checkInterval' => '',
    'failureThreshold' => 0,
    'host' => '',
    'initialDelay' => '',
    'path' => '',
    'successThreshold' => 0,
    'timeout' => ''
  ],
  'manualScaling' => [
    'instances' => 0
  ],
  'name' => '',
  'network' => [
    'forwardedPorts' => [
        
    ],
    'instanceIpMode' => '',
    'instanceTag' => '',
    'name' => '',
    'sessionAffinity' => null,
    'subnetworkName' => ''
  ],
  'nobuildFilesRegex' => '',
  'readinessCheck' => [
    'appStartTimeout' => '',
    'checkInterval' => '',
    'failureThreshold' => 0,
    'host' => '',
    'path' => '',
    'successThreshold' => 0,
    'timeout' => ''
  ],
  'resources' => [
    'cpu' => '',
    'diskGb' => '',
    'kmsKeyReference' => '',
    'memoryGb' => '',
    'volumes' => [
        [
                'name' => '',
                'sizeGb' => '',
                'volumeType' => ''
        ]
    ]
  ],
  'runtime' => '',
  'runtimeApiVersion' => '',
  'runtimeChannel' => '',
  'runtimeMainExecutablePath' => '',
  'serviceAccount' => '',
  'servingStatus' => '',
  'threadsafe' => null,
  'versionUrl' => '',
  'vm' => null,
  'vpcAccessConnector' => [
    'egressSetting' => '',
    'name' => ''
  ],
  'zones' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId');
$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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}'

import http.client

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

payload = "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\n}"

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

conn.request("PATCH", "/baseUrl/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId", payload, headers)

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

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"

payload = {
    "apiConfig": {
        "authFailAction": "",
        "login": "",
        "script": "",
        "securityLevel": "",
        "url": ""
    },
    "appEngineApis": False,
    "automaticScaling": {
        "coolDownPeriod": "",
        "cpuUtilization": {
            "aggregationWindowLength": "",
            "targetUtilization": ""
        },
        "customMetrics": [
            {
                "filter": "",
                "metricName": "",
                "singleInstanceAssignment": "",
                "targetType": "",
                "targetUtilization": ""
            }
        ],
        "diskUtilization": {
            "targetReadBytesPerSecond": 0,
            "targetReadOpsPerSecond": 0,
            "targetWriteBytesPerSecond": 0,
            "targetWriteOpsPerSecond": 0
        },
        "maxConcurrentRequests": 0,
        "maxIdleInstances": 0,
        "maxPendingLatency": "",
        "maxTotalInstances": 0,
        "minIdleInstances": 0,
        "minPendingLatency": "",
        "minTotalInstances": 0,
        "networkUtilization": {
            "targetReceivedBytesPerSecond": 0,
            "targetReceivedPacketsPerSecond": 0,
            "targetSentBytesPerSecond": 0,
            "targetSentPacketsPerSecond": 0
        },
        "requestUtilization": {
            "targetConcurrentRequests": 0,
            "targetRequestCountPerSecond": 0
        },
        "standardSchedulerSettings": {
            "maxInstances": 0,
            "minInstances": 0,
            "targetCpuUtilization": "",
            "targetThroughputUtilization": ""
        }
    },
    "basicScaling": {
        "idleTimeout": "",
        "maxInstances": 0
    },
    "betaSettings": {},
    "buildEnvVariables": {},
    "createTime": "",
    "createdBy": "",
    "defaultExpiration": "",
    "deployment": {
        "build": { "cloudBuildId": "" },
        "cloudBuildOptions": {
            "appYamlPath": "",
            "cloudBuildTimeout": ""
        },
        "container": { "image": "" },
        "files": {},
        "zip": {
            "filesCount": 0,
            "sourceUrl": ""
        }
    },
    "diskUsageBytes": "",
    "endpointsApiService": {
        "configId": "",
        "disableTraceSampling": False,
        "name": "",
        "rolloutStrategy": ""
    },
    "entrypoint": { "shell": "" },
    "env": "",
    "envVariables": {},
    "errorHandlers": [
        {
            "errorCode": "",
            "mimeType": "",
            "staticFile": ""
        }
    ],
    "flexibleRuntimeSettings": {
        "operatingSystem": "",
        "runtimeVersion": ""
    },
    "handlers": [
        {
            "apiEndpoint": { "scriptPath": "" },
            "authFailAction": "",
            "login": "",
            "redirectHttpResponseCode": "",
            "script": { "scriptPath": "" },
            "securityLevel": "",
            "staticFiles": {
                "applicationReadable": False,
                "expiration": "",
                "httpHeaders": {},
                "mimeType": "",
                "path": "",
                "requireMatchingFile": False,
                "uploadPathRegex": ""
            },
            "urlRegex": ""
        }
    ],
    "healthCheck": {
        "checkInterval": "",
        "disableHealthCheck": False,
        "healthyThreshold": 0,
        "host": "",
        "restartThreshold": 0,
        "timeout": "",
        "unhealthyThreshold": 0
    },
    "id": "",
    "inboundServices": [],
    "instanceClass": "",
    "libraries": [
        {
            "name": "",
            "version": ""
        }
    ],
    "livenessCheck": {
        "checkInterval": "",
        "failureThreshold": 0,
        "host": "",
        "initialDelay": "",
        "path": "",
        "successThreshold": 0,
        "timeout": ""
    },
    "manualScaling": { "instances": 0 },
    "name": "",
    "network": {
        "forwardedPorts": [],
        "instanceIpMode": "",
        "instanceTag": "",
        "name": "",
        "sessionAffinity": False,
        "subnetworkName": ""
    },
    "nobuildFilesRegex": "",
    "readinessCheck": {
        "appStartTimeout": "",
        "checkInterval": "",
        "failureThreshold": 0,
        "host": "",
        "path": "",
        "successThreshold": 0,
        "timeout": ""
    },
    "resources": {
        "cpu": "",
        "diskGb": "",
        "kmsKeyReference": "",
        "memoryGb": "",
        "volumes": [
            {
                "name": "",
                "sizeGb": "",
                "volumeType": ""
            }
        ]
    },
    "runtime": "",
    "runtimeApiVersion": "",
    "runtimeChannel": "",
    "runtimeMainExecutablePath": "",
    "serviceAccount": "",
    "servingStatus": "",
    "threadsafe": False,
    "versionUrl": "",
    "vm": False,
    "vpcAccessConnector": {
        "egressSetting": "",
        "name": ""
    },
    "zones": []
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId"

payload <- "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")

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  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId') do |req|
  req.body = "{\n  \"apiConfig\": {\n    \"authFailAction\": \"\",\n    \"login\": \"\",\n    \"script\": \"\",\n    \"securityLevel\": \"\",\n    \"url\": \"\"\n  },\n  \"appEngineApis\": false,\n  \"automaticScaling\": {\n    \"coolDownPeriod\": \"\",\n    \"cpuUtilization\": {\n      \"aggregationWindowLength\": \"\",\n      \"targetUtilization\": \"\"\n    },\n    \"customMetrics\": [\n      {\n        \"filter\": \"\",\n        \"metricName\": \"\",\n        \"singleInstanceAssignment\": \"\",\n        \"targetType\": \"\",\n        \"targetUtilization\": \"\"\n      }\n    ],\n    \"diskUtilization\": {\n      \"targetReadBytesPerSecond\": 0,\n      \"targetReadOpsPerSecond\": 0,\n      \"targetWriteBytesPerSecond\": 0,\n      \"targetWriteOpsPerSecond\": 0\n    },\n    \"maxConcurrentRequests\": 0,\n    \"maxIdleInstances\": 0,\n    \"maxPendingLatency\": \"\",\n    \"maxTotalInstances\": 0,\n    \"minIdleInstances\": 0,\n    \"minPendingLatency\": \"\",\n    \"minTotalInstances\": 0,\n    \"networkUtilization\": {\n      \"targetReceivedBytesPerSecond\": 0,\n      \"targetReceivedPacketsPerSecond\": 0,\n      \"targetSentBytesPerSecond\": 0,\n      \"targetSentPacketsPerSecond\": 0\n    },\n    \"requestUtilization\": {\n      \"targetConcurrentRequests\": 0,\n      \"targetRequestCountPerSecond\": 0\n    },\n    \"standardSchedulerSettings\": {\n      \"maxInstances\": 0,\n      \"minInstances\": 0,\n      \"targetCpuUtilization\": \"\",\n      \"targetThroughputUtilization\": \"\"\n    }\n  },\n  \"basicScaling\": {\n    \"idleTimeout\": \"\",\n    \"maxInstances\": 0\n  },\n  \"betaSettings\": {},\n  \"buildEnvVariables\": {},\n  \"createTime\": \"\",\n  \"createdBy\": \"\",\n  \"defaultExpiration\": \"\",\n  \"deployment\": {\n    \"build\": {\n      \"cloudBuildId\": \"\"\n    },\n    \"cloudBuildOptions\": {\n      \"appYamlPath\": \"\",\n      \"cloudBuildTimeout\": \"\"\n    },\n    \"container\": {\n      \"image\": \"\"\n    },\n    \"files\": {},\n    \"zip\": {\n      \"filesCount\": 0,\n      \"sourceUrl\": \"\"\n    }\n  },\n  \"diskUsageBytes\": \"\",\n  \"endpointsApiService\": {\n    \"configId\": \"\",\n    \"disableTraceSampling\": false,\n    \"name\": \"\",\n    \"rolloutStrategy\": \"\"\n  },\n  \"entrypoint\": {\n    \"shell\": \"\"\n  },\n  \"env\": \"\",\n  \"envVariables\": {},\n  \"errorHandlers\": [\n    {\n      \"errorCode\": \"\",\n      \"mimeType\": \"\",\n      \"staticFile\": \"\"\n    }\n  ],\n  \"flexibleRuntimeSettings\": {\n    \"operatingSystem\": \"\",\n    \"runtimeVersion\": \"\"\n  },\n  \"handlers\": [\n    {\n      \"apiEndpoint\": {\n        \"scriptPath\": \"\"\n      },\n      \"authFailAction\": \"\",\n      \"login\": \"\",\n      \"redirectHttpResponseCode\": \"\",\n      \"script\": {\n        \"scriptPath\": \"\"\n      },\n      \"securityLevel\": \"\",\n      \"staticFiles\": {\n        \"applicationReadable\": false,\n        \"expiration\": \"\",\n        \"httpHeaders\": {},\n        \"mimeType\": \"\",\n        \"path\": \"\",\n        \"requireMatchingFile\": false,\n        \"uploadPathRegex\": \"\"\n      },\n      \"urlRegex\": \"\"\n    }\n  ],\n  \"healthCheck\": {\n    \"checkInterval\": \"\",\n    \"disableHealthCheck\": false,\n    \"healthyThreshold\": 0,\n    \"host\": \"\",\n    \"restartThreshold\": 0,\n    \"timeout\": \"\",\n    \"unhealthyThreshold\": 0\n  },\n  \"id\": \"\",\n  \"inboundServices\": [],\n  \"instanceClass\": \"\",\n  \"libraries\": [\n    {\n      \"name\": \"\",\n      \"version\": \"\"\n    }\n  ],\n  \"livenessCheck\": {\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"initialDelay\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"manualScaling\": {\n    \"instances\": 0\n  },\n  \"name\": \"\",\n  \"network\": {\n    \"forwardedPorts\": [],\n    \"instanceIpMode\": \"\",\n    \"instanceTag\": \"\",\n    \"name\": \"\",\n    \"sessionAffinity\": false,\n    \"subnetworkName\": \"\"\n  },\n  \"nobuildFilesRegex\": \"\",\n  \"readinessCheck\": {\n    \"appStartTimeout\": \"\",\n    \"checkInterval\": \"\",\n    \"failureThreshold\": 0,\n    \"host\": \"\",\n    \"path\": \"\",\n    \"successThreshold\": 0,\n    \"timeout\": \"\"\n  },\n  \"resources\": {\n    \"cpu\": \"\",\n    \"diskGb\": \"\",\n    \"kmsKeyReference\": \"\",\n    \"memoryGb\": \"\",\n    \"volumes\": [\n      {\n        \"name\": \"\",\n        \"sizeGb\": \"\",\n        \"volumeType\": \"\"\n      }\n    ]\n  },\n  \"runtime\": \"\",\n  \"runtimeApiVersion\": \"\",\n  \"runtimeChannel\": \"\",\n  \"runtimeMainExecutablePath\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\",\n  \"threadsafe\": false,\n  \"versionUrl\": \"\",\n  \"vm\": false,\n  \"vpcAccessConnector\": {\n    \"egressSetting\": \"\",\n    \"name\": \"\"\n  },\n  \"zones\": []\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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId";

    let payload = json!({
        "apiConfig": json!({
            "authFailAction": "",
            "login": "",
            "script": "",
            "securityLevel": "",
            "url": ""
        }),
        "appEngineApis": false,
        "automaticScaling": json!({
            "coolDownPeriod": "",
            "cpuUtilization": json!({
                "aggregationWindowLength": "",
                "targetUtilization": ""
            }),
            "customMetrics": (
                json!({
                    "filter": "",
                    "metricName": "",
                    "singleInstanceAssignment": "",
                    "targetType": "",
                    "targetUtilization": ""
                })
            ),
            "diskUtilization": json!({
                "targetReadBytesPerSecond": 0,
                "targetReadOpsPerSecond": 0,
                "targetWriteBytesPerSecond": 0,
                "targetWriteOpsPerSecond": 0
            }),
            "maxConcurrentRequests": 0,
            "maxIdleInstances": 0,
            "maxPendingLatency": "",
            "maxTotalInstances": 0,
            "minIdleInstances": 0,
            "minPendingLatency": "",
            "minTotalInstances": 0,
            "networkUtilization": json!({
                "targetReceivedBytesPerSecond": 0,
                "targetReceivedPacketsPerSecond": 0,
                "targetSentBytesPerSecond": 0,
                "targetSentPacketsPerSecond": 0
            }),
            "requestUtilization": json!({
                "targetConcurrentRequests": 0,
                "targetRequestCountPerSecond": 0
            }),
            "standardSchedulerSettings": json!({
                "maxInstances": 0,
                "minInstances": 0,
                "targetCpuUtilization": "",
                "targetThroughputUtilization": ""
            })
        }),
        "basicScaling": json!({
            "idleTimeout": "",
            "maxInstances": 0
        }),
        "betaSettings": json!({}),
        "buildEnvVariables": json!({}),
        "createTime": "",
        "createdBy": "",
        "defaultExpiration": "",
        "deployment": json!({
            "build": json!({"cloudBuildId": ""}),
            "cloudBuildOptions": json!({
                "appYamlPath": "",
                "cloudBuildTimeout": ""
            }),
            "container": json!({"image": ""}),
            "files": json!({}),
            "zip": json!({
                "filesCount": 0,
                "sourceUrl": ""
            })
        }),
        "diskUsageBytes": "",
        "endpointsApiService": json!({
            "configId": "",
            "disableTraceSampling": false,
            "name": "",
            "rolloutStrategy": ""
        }),
        "entrypoint": json!({"shell": ""}),
        "env": "",
        "envVariables": json!({}),
        "errorHandlers": (
            json!({
                "errorCode": "",
                "mimeType": "",
                "staticFile": ""
            })
        ),
        "flexibleRuntimeSettings": json!({
            "operatingSystem": "",
            "runtimeVersion": ""
        }),
        "handlers": (
            json!({
                "apiEndpoint": json!({"scriptPath": ""}),
                "authFailAction": "",
                "login": "",
                "redirectHttpResponseCode": "",
                "script": json!({"scriptPath": ""}),
                "securityLevel": "",
                "staticFiles": json!({
                    "applicationReadable": false,
                    "expiration": "",
                    "httpHeaders": json!({}),
                    "mimeType": "",
                    "path": "",
                    "requireMatchingFile": false,
                    "uploadPathRegex": ""
                }),
                "urlRegex": ""
            })
        ),
        "healthCheck": json!({
            "checkInterval": "",
            "disableHealthCheck": false,
            "healthyThreshold": 0,
            "host": "",
            "restartThreshold": 0,
            "timeout": "",
            "unhealthyThreshold": 0
        }),
        "id": "",
        "inboundServices": (),
        "instanceClass": "",
        "libraries": (
            json!({
                "name": "",
                "version": ""
            })
        ),
        "livenessCheck": json!({
            "checkInterval": "",
            "failureThreshold": 0,
            "host": "",
            "initialDelay": "",
            "path": "",
            "successThreshold": 0,
            "timeout": ""
        }),
        "manualScaling": json!({"instances": 0}),
        "name": "",
        "network": json!({
            "forwardedPorts": (),
            "instanceIpMode": "",
            "instanceTag": "",
            "name": "",
            "sessionAffinity": false,
            "subnetworkName": ""
        }),
        "nobuildFilesRegex": "",
        "readinessCheck": json!({
            "appStartTimeout": "",
            "checkInterval": "",
            "failureThreshold": 0,
            "host": "",
            "path": "",
            "successThreshold": 0,
            "timeout": ""
        }),
        "resources": json!({
            "cpu": "",
            "diskGb": "",
            "kmsKeyReference": "",
            "memoryGb": "",
            "volumes": (
                json!({
                    "name": "",
                    "sizeGb": "",
                    "volumeType": ""
                })
            )
        }),
        "runtime": "",
        "runtimeApiVersion": "",
        "runtimeChannel": "",
        "runtimeMainExecutablePath": "",
        "serviceAccount": "",
        "servingStatus": "",
        "threadsafe": false,
        "versionUrl": "",
        "vm": false,
        "vpcAccessConnector": json!({
            "egressSetting": "",
            "name": ""
        }),
        "zones": ()
    });

    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}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId \
  --header 'content-type: application/json' \
  --data '{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}'

echo '{
  "apiConfig": {
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  },
  "appEngineApis": false,
  "automaticScaling": {
    "coolDownPeriod": "",
    "cpuUtilization": {
      "aggregationWindowLength": "",
      "targetUtilization": ""
    },
    "customMetrics": [
      {
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      }
    ],
    "diskUtilization": {
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    },
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": {
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    },
    "requestUtilization": {
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    },
    "standardSchedulerSettings": {
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    }
  },
  "basicScaling": {
    "idleTimeout": "",
    "maxInstances": 0
  },
  "betaSettings": {},
  "buildEnvVariables": {},
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": {
    "build": {
      "cloudBuildId": ""
    },
    "cloudBuildOptions": {
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    },
    "container": {
      "image": ""
    },
    "files": {},
    "zip": {
      "filesCount": 0,
      "sourceUrl": ""
    }
  },
  "diskUsageBytes": "",
  "endpointsApiService": {
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  },
  "entrypoint": {
    "shell": ""
  },
  "env": "",
  "envVariables": {},
  "errorHandlers": [
    {
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    }
  ],
  "flexibleRuntimeSettings": {
    "operatingSystem": "",
    "runtimeVersion": ""
  },
  "handlers": [
    {
      "apiEndpoint": {
        "scriptPath": ""
      },
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": {
        "scriptPath": ""
      },
      "securityLevel": "",
      "staticFiles": {
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": {},
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      },
      "urlRegex": ""
    }
  ],
  "healthCheck": {
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  },
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    {
      "name": "",
      "version": ""
    }
  ],
  "livenessCheck": {
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "manualScaling": {
    "instances": 0
  },
  "name": "",
  "network": {
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  },
  "nobuildFilesRegex": "",
  "readinessCheck": {
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  },
  "resources": {
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      {
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      }
    ]
  },
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": {
    "egressSetting": "",
    "name": ""
  },
  "zones": []
}' |  \
  http PATCH {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "apiConfig": {\n    "authFailAction": "",\n    "login": "",\n    "script": "",\n    "securityLevel": "",\n    "url": ""\n  },\n  "appEngineApis": false,\n  "automaticScaling": {\n    "coolDownPeriod": "",\n    "cpuUtilization": {\n      "aggregationWindowLength": "",\n      "targetUtilization": ""\n    },\n    "customMetrics": [\n      {\n        "filter": "",\n        "metricName": "",\n        "singleInstanceAssignment": "",\n        "targetType": "",\n        "targetUtilization": ""\n      }\n    ],\n    "diskUtilization": {\n      "targetReadBytesPerSecond": 0,\n      "targetReadOpsPerSecond": 0,\n      "targetWriteBytesPerSecond": 0,\n      "targetWriteOpsPerSecond": 0\n    },\n    "maxConcurrentRequests": 0,\n    "maxIdleInstances": 0,\n    "maxPendingLatency": "",\n    "maxTotalInstances": 0,\n    "minIdleInstances": 0,\n    "minPendingLatency": "",\n    "minTotalInstances": 0,\n    "networkUtilization": {\n      "targetReceivedBytesPerSecond": 0,\n      "targetReceivedPacketsPerSecond": 0,\n      "targetSentBytesPerSecond": 0,\n      "targetSentPacketsPerSecond": 0\n    },\n    "requestUtilization": {\n      "targetConcurrentRequests": 0,\n      "targetRequestCountPerSecond": 0\n    },\n    "standardSchedulerSettings": {\n      "maxInstances": 0,\n      "minInstances": 0,\n      "targetCpuUtilization": "",\n      "targetThroughputUtilization": ""\n    }\n  },\n  "basicScaling": {\n    "idleTimeout": "",\n    "maxInstances": 0\n  },\n  "betaSettings": {},\n  "buildEnvVariables": {},\n  "createTime": "",\n  "createdBy": "",\n  "defaultExpiration": "",\n  "deployment": {\n    "build": {\n      "cloudBuildId": ""\n    },\n    "cloudBuildOptions": {\n      "appYamlPath": "",\n      "cloudBuildTimeout": ""\n    },\n    "container": {\n      "image": ""\n    },\n    "files": {},\n    "zip": {\n      "filesCount": 0,\n      "sourceUrl": ""\n    }\n  },\n  "diskUsageBytes": "",\n  "endpointsApiService": {\n    "configId": "",\n    "disableTraceSampling": false,\n    "name": "",\n    "rolloutStrategy": ""\n  },\n  "entrypoint": {\n    "shell": ""\n  },\n  "env": "",\n  "envVariables": {},\n  "errorHandlers": [\n    {\n      "errorCode": "",\n      "mimeType": "",\n      "staticFile": ""\n    }\n  ],\n  "flexibleRuntimeSettings": {\n    "operatingSystem": "",\n    "runtimeVersion": ""\n  },\n  "handlers": [\n    {\n      "apiEndpoint": {\n        "scriptPath": ""\n      },\n      "authFailAction": "",\n      "login": "",\n      "redirectHttpResponseCode": "",\n      "script": {\n        "scriptPath": ""\n      },\n      "securityLevel": "",\n      "staticFiles": {\n        "applicationReadable": false,\n        "expiration": "",\n        "httpHeaders": {},\n        "mimeType": "",\n        "path": "",\n        "requireMatchingFile": false,\n        "uploadPathRegex": ""\n      },\n      "urlRegex": ""\n    }\n  ],\n  "healthCheck": {\n    "checkInterval": "",\n    "disableHealthCheck": false,\n    "healthyThreshold": 0,\n    "host": "",\n    "restartThreshold": 0,\n    "timeout": "",\n    "unhealthyThreshold": 0\n  },\n  "id": "",\n  "inboundServices": [],\n  "instanceClass": "",\n  "libraries": [\n    {\n      "name": "",\n      "version": ""\n    }\n  ],\n  "livenessCheck": {\n    "checkInterval": "",\n    "failureThreshold": 0,\n    "host": "",\n    "initialDelay": "",\n    "path": "",\n    "successThreshold": 0,\n    "timeout": ""\n  },\n  "manualScaling": {\n    "instances": 0\n  },\n  "name": "",\n  "network": {\n    "forwardedPorts": [],\n    "instanceIpMode": "",\n    "instanceTag": "",\n    "name": "",\n    "sessionAffinity": false,\n    "subnetworkName": ""\n  },\n  "nobuildFilesRegex": "",\n  "readinessCheck": {\n    "appStartTimeout": "",\n    "checkInterval": "",\n    "failureThreshold": 0,\n    "host": "",\n    "path": "",\n    "successThreshold": 0,\n    "timeout": ""\n  },\n  "resources": {\n    "cpu": "",\n    "diskGb": "",\n    "kmsKeyReference": "",\n    "memoryGb": "",\n    "volumes": [\n      {\n        "name": "",\n        "sizeGb": "",\n        "volumeType": ""\n      }\n    ]\n  },\n  "runtime": "",\n  "runtimeApiVersion": "",\n  "runtimeChannel": "",\n  "runtimeMainExecutablePath": "",\n  "serviceAccount": "",\n  "servingStatus": "",\n  "threadsafe": false,\n  "versionUrl": "",\n  "vm": false,\n  "vpcAccessConnector": {\n    "egressSetting": "",\n    "name": ""\n  },\n  "zones": []\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "apiConfig": [
    "authFailAction": "",
    "login": "",
    "script": "",
    "securityLevel": "",
    "url": ""
  ],
  "appEngineApis": false,
  "automaticScaling": [
    "coolDownPeriod": "",
    "cpuUtilization": [
      "aggregationWindowLength": "",
      "targetUtilization": ""
    ],
    "customMetrics": [
      [
        "filter": "",
        "metricName": "",
        "singleInstanceAssignment": "",
        "targetType": "",
        "targetUtilization": ""
      ]
    ],
    "diskUtilization": [
      "targetReadBytesPerSecond": 0,
      "targetReadOpsPerSecond": 0,
      "targetWriteBytesPerSecond": 0,
      "targetWriteOpsPerSecond": 0
    ],
    "maxConcurrentRequests": 0,
    "maxIdleInstances": 0,
    "maxPendingLatency": "",
    "maxTotalInstances": 0,
    "minIdleInstances": 0,
    "minPendingLatency": "",
    "minTotalInstances": 0,
    "networkUtilization": [
      "targetReceivedBytesPerSecond": 0,
      "targetReceivedPacketsPerSecond": 0,
      "targetSentBytesPerSecond": 0,
      "targetSentPacketsPerSecond": 0
    ],
    "requestUtilization": [
      "targetConcurrentRequests": 0,
      "targetRequestCountPerSecond": 0
    ],
    "standardSchedulerSettings": [
      "maxInstances": 0,
      "minInstances": 0,
      "targetCpuUtilization": "",
      "targetThroughputUtilization": ""
    ]
  ],
  "basicScaling": [
    "idleTimeout": "",
    "maxInstances": 0
  ],
  "betaSettings": [],
  "buildEnvVariables": [],
  "createTime": "",
  "createdBy": "",
  "defaultExpiration": "",
  "deployment": [
    "build": ["cloudBuildId": ""],
    "cloudBuildOptions": [
      "appYamlPath": "",
      "cloudBuildTimeout": ""
    ],
    "container": ["image": ""],
    "files": [],
    "zip": [
      "filesCount": 0,
      "sourceUrl": ""
    ]
  ],
  "diskUsageBytes": "",
  "endpointsApiService": [
    "configId": "",
    "disableTraceSampling": false,
    "name": "",
    "rolloutStrategy": ""
  ],
  "entrypoint": ["shell": ""],
  "env": "",
  "envVariables": [],
  "errorHandlers": [
    [
      "errorCode": "",
      "mimeType": "",
      "staticFile": ""
    ]
  ],
  "flexibleRuntimeSettings": [
    "operatingSystem": "",
    "runtimeVersion": ""
  ],
  "handlers": [
    [
      "apiEndpoint": ["scriptPath": ""],
      "authFailAction": "",
      "login": "",
      "redirectHttpResponseCode": "",
      "script": ["scriptPath": ""],
      "securityLevel": "",
      "staticFiles": [
        "applicationReadable": false,
        "expiration": "",
        "httpHeaders": [],
        "mimeType": "",
        "path": "",
        "requireMatchingFile": false,
        "uploadPathRegex": ""
      ],
      "urlRegex": ""
    ]
  ],
  "healthCheck": [
    "checkInterval": "",
    "disableHealthCheck": false,
    "healthyThreshold": 0,
    "host": "",
    "restartThreshold": 0,
    "timeout": "",
    "unhealthyThreshold": 0
  ],
  "id": "",
  "inboundServices": [],
  "instanceClass": "",
  "libraries": [
    [
      "name": "",
      "version": ""
    ]
  ],
  "livenessCheck": [
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "initialDelay": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  ],
  "manualScaling": ["instances": 0],
  "name": "",
  "network": [
    "forwardedPorts": [],
    "instanceIpMode": "",
    "instanceTag": "",
    "name": "",
    "sessionAffinity": false,
    "subnetworkName": ""
  ],
  "nobuildFilesRegex": "",
  "readinessCheck": [
    "appStartTimeout": "",
    "checkInterval": "",
    "failureThreshold": 0,
    "host": "",
    "path": "",
    "successThreshold": 0,
    "timeout": ""
  ],
  "resources": [
    "cpu": "",
    "diskGb": "",
    "kmsKeyReference": "",
    "memoryGb": "",
    "volumes": [
      [
        "name": "",
        "sizeGb": "",
        "volumeType": ""
      ]
    ]
  ],
  "runtime": "",
  "runtimeApiVersion": "",
  "runtimeChannel": "",
  "runtimeMainExecutablePath": "",
  "serviceAccount": "",
  "servingStatus": "",
  "threadsafe": false,
  "versionUrl": "",
  "vm": false,
  "vpcAccessConnector": [
    "egressSetting": "",
    "name": ""
  ],
  "zones": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/apps/:appsId/services/:servicesId/versions/:versionsId")! 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 appengine.projects.locations.applications.create

{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications

QUERY PARAMS

projectsId

locationsId

BODY json

{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications");

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  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications" {:content-type :json
                                                                                                            :form-params {:authDomain ""
                                                                                                                          :codeBucket ""
                                                                                                                          :databaseType ""
                                                                                                                          :defaultBucket ""
                                                                                                                          :defaultCookieExpiration ""
                                                                                                                          :defaultHostname ""
                                                                                                                          :dispatchRules [{:domain ""
                                                                                                                                           :path ""
                                                                                                                                           :service ""}]
                                                                                                                          :featureSettings {:splitHealthChecks false
                                                                                                                                            :useContainerOptimizedOs false}
                                                                                                                          :gcrDomain ""
                                                                                                                          :iap {:enabled false
                                                                                                                                :oauth2ClientId ""
                                                                                                                                :oauth2ClientSecret ""
                                                                                                                                :oauth2ClientSecretSha256 ""}
                                                                                                                          :id ""
                                                                                                                          :locationId ""
                                                                                                                          :name ""
                                                                                                                          :serviceAccount ""
                                                                                                                          :servingStatus ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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}}/v1beta/projects/:projectsId/locations/:locationsId/applications"),
    Content = new StringContent("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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}}/v1beta/projects/:projectsId/locations/:locationsId/applications");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications"

	payload := strings.NewReader("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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/v1beta/projects/:projectsId/locations/:locationsId/applications HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 579

{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications")
  .header("content-type", "application/json")
  .body("{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  authDomain: '',
  codeBucket: '',
  databaseType: '',
  defaultBucket: '',
  defaultCookieExpiration: '',
  defaultHostname: '',
  dispatchRules: [
    {
      domain: '',
      path: '',
      service: ''
    }
  ],
  featureSettings: {
    splitHealthChecks: false,
    useContainerOptimizedOs: false
  },
  gcrDomain: '',
  iap: {
    enabled: false,
    oauth2ClientId: '',
    oauth2ClientSecret: '',
    oauth2ClientSecretSha256: ''
  },
  id: '',
  locationId: '',
  name: '',
  serviceAccount: '',
  servingStatus: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications',
  headers: {'content-type': 'application/json'},
  data: {
    authDomain: '',
    codeBucket: '',
    databaseType: '',
    defaultBucket: '',
    defaultCookieExpiration: '',
    defaultHostname: '',
    dispatchRules: [{domain: '', path: '', service: ''}],
    featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
    gcrDomain: '',
    iap: {
      enabled: false,
      oauth2ClientId: '',
      oauth2ClientSecret: '',
      oauth2ClientSecretSha256: ''
    },
    id: '',
    locationId: '',
    name: '',
    serviceAccount: '',
    servingStatus: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authDomain":"","codeBucket":"","databaseType":"","defaultBucket":"","defaultCookieExpiration":"","defaultHostname":"","dispatchRules":[{"domain":"","path":"","service":""}],"featureSettings":{"splitHealthChecks":false,"useContainerOptimizedOs":false},"gcrDomain":"","iap":{"enabled":false,"oauth2ClientId":"","oauth2ClientSecret":"","oauth2ClientSecretSha256":""},"id":"","locationId":"","name":"","serviceAccount":"","servingStatus":""}'
};

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}}/v1beta/projects/:projectsId/locations/:locationsId/applications',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authDomain": "",\n  "codeBucket": "",\n  "databaseType": "",\n  "defaultBucket": "",\n  "defaultCookieExpiration": "",\n  "defaultHostname": "",\n  "dispatchRules": [\n    {\n      "domain": "",\n      "path": "",\n      "service": ""\n    }\n  ],\n  "featureSettings": {\n    "splitHealthChecks": false,\n    "useContainerOptimizedOs": false\n  },\n  "gcrDomain": "",\n  "iap": {\n    "enabled": false,\n    "oauth2ClientId": "",\n    "oauth2ClientSecret": "",\n    "oauth2ClientSecretSha256": ""\n  },\n  "id": "",\n  "locationId": "",\n  "name": "",\n  "serviceAccount": "",\n  "servingStatus": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications")
  .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/v1beta/projects/:projectsId/locations/:locationsId/applications',
  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({
  authDomain: '',
  codeBucket: '',
  databaseType: '',
  defaultBucket: '',
  defaultCookieExpiration: '',
  defaultHostname: '',
  dispatchRules: [{domain: '', path: '', service: ''}],
  featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
  gcrDomain: '',
  iap: {
    enabled: false,
    oauth2ClientId: '',
    oauth2ClientSecret: '',
    oauth2ClientSecretSha256: ''
  },
  id: '',
  locationId: '',
  name: '',
  serviceAccount: '',
  servingStatus: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications',
  headers: {'content-type': 'application/json'},
  body: {
    authDomain: '',
    codeBucket: '',
    databaseType: '',
    defaultBucket: '',
    defaultCookieExpiration: '',
    defaultHostname: '',
    dispatchRules: [{domain: '', path: '', service: ''}],
    featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
    gcrDomain: '',
    iap: {
      enabled: false,
      oauth2ClientId: '',
      oauth2ClientSecret: '',
      oauth2ClientSecretSha256: ''
    },
    id: '',
    locationId: '',
    name: '',
    serviceAccount: '',
    servingStatus: ''
  },
  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}}/v1beta/projects/:projectsId/locations/:locationsId/applications');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  authDomain: '',
  codeBucket: '',
  databaseType: '',
  defaultBucket: '',
  defaultCookieExpiration: '',
  defaultHostname: '',
  dispatchRules: [
    {
      domain: '',
      path: '',
      service: ''
    }
  ],
  featureSettings: {
    splitHealthChecks: false,
    useContainerOptimizedOs: false
  },
  gcrDomain: '',
  iap: {
    enabled: false,
    oauth2ClientId: '',
    oauth2ClientSecret: '',
    oauth2ClientSecretSha256: ''
  },
  id: '',
  locationId: '',
  name: '',
  serviceAccount: '',
  servingStatus: ''
});

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}}/v1beta/projects/:projectsId/locations/:locationsId/applications',
  headers: {'content-type': 'application/json'},
  data: {
    authDomain: '',
    codeBucket: '',
    databaseType: '',
    defaultBucket: '',
    defaultCookieExpiration: '',
    defaultHostname: '',
    dispatchRules: [{domain: '', path: '', service: ''}],
    featureSettings: {splitHealthChecks: false, useContainerOptimizedOs: false},
    gcrDomain: '',
    iap: {
      enabled: false,
      oauth2ClientId: '',
      oauth2ClientSecret: '',
      oauth2ClientSecretSha256: ''
    },
    id: '',
    locationId: '',
    name: '',
    serviceAccount: '',
    servingStatus: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authDomain":"","codeBucket":"","databaseType":"","defaultBucket":"","defaultCookieExpiration":"","defaultHostname":"","dispatchRules":[{"domain":"","path":"","service":""}],"featureSettings":{"splitHealthChecks":false,"useContainerOptimizedOs":false},"gcrDomain":"","iap":{"enabled":false,"oauth2ClientId":"","oauth2ClientSecret":"","oauth2ClientSecretSha256":""},"id":"","locationId":"","name":"","serviceAccount":"","servingStatus":""}'
};

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 = @{ @"authDomain": @"",
                              @"codeBucket": @"",
                              @"databaseType": @"",
                              @"defaultBucket": @"",
                              @"defaultCookieExpiration": @"",
                              @"defaultHostname": @"",
                              @"dispatchRules": @[ @{ @"domain": @"", @"path": @"", @"service": @"" } ],
                              @"featureSettings": @{ @"splitHealthChecks": @NO, @"useContainerOptimizedOs": @NO },
                              @"gcrDomain": @"",
                              @"iap": @{ @"enabled": @NO, @"oauth2ClientId": @"", @"oauth2ClientSecret": @"", @"oauth2ClientSecretSha256": @"" },
                              @"id": @"",
                              @"locationId": @"",
                              @"name": @"",
                              @"serviceAccount": @"",
                              @"servingStatus": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications"]
                                                       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}}/v1beta/projects/:projectsId/locations/:locationsId/applications" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications",
  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([
    'authDomain' => '',
    'codeBucket' => '',
    'databaseType' => '',
    'defaultBucket' => '',
    'defaultCookieExpiration' => '',
    'defaultHostname' => '',
    'dispatchRules' => [
        [
                'domain' => '',
                'path' => '',
                'service' => ''
        ]
    ],
    'featureSettings' => [
        'splitHealthChecks' => null,
        'useContainerOptimizedOs' => null
    ],
    'gcrDomain' => '',
    'iap' => [
        'enabled' => null,
        'oauth2ClientId' => '',
        'oauth2ClientSecret' => '',
        'oauth2ClientSecretSha256' => ''
    ],
    'id' => '',
    'locationId' => '',
    'name' => '',
    'serviceAccount' => '',
    'servingStatus' => ''
  ]),
  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}}/v1beta/projects/:projectsId/locations/:locationsId/applications', [
  'body' => '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authDomain' => '',
  'codeBucket' => '',
  'databaseType' => '',
  'defaultBucket' => '',
  'defaultCookieExpiration' => '',
  'defaultHostname' => '',
  'dispatchRules' => [
    [
        'domain' => '',
        'path' => '',
        'service' => ''
    ]
  ],
  'featureSettings' => [
    'splitHealthChecks' => null,
    'useContainerOptimizedOs' => null
  ],
  'gcrDomain' => '',
  'iap' => [
    'enabled' => null,
    'oauth2ClientId' => '',
    'oauth2ClientSecret' => '',
    'oauth2ClientSecretSha256' => ''
  ],
  'id' => '',
  'locationId' => '',
  'name' => '',
  'serviceAccount' => '',
  'servingStatus' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'authDomain' => '',
  'codeBucket' => '',
  'databaseType' => '',
  'defaultBucket' => '',
  'defaultCookieExpiration' => '',
  'defaultHostname' => '',
  'dispatchRules' => [
    [
        'domain' => '',
        'path' => '',
        'service' => ''
    ]
  ],
  'featureSettings' => [
    'splitHealthChecks' => null,
    'useContainerOptimizedOs' => null
  ],
  'gcrDomain' => '',
  'iap' => [
    'enabled' => null,
    'oauth2ClientId' => '',
    'oauth2ClientSecret' => '',
    'oauth2ClientSecretSha256' => ''
  ],
  'id' => '',
  'locationId' => '',
  'name' => '',
  'serviceAccount' => '',
  'servingStatus' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications');
$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}}/v1beta/projects/:projectsId/locations/:locationsId/applications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1beta/projects/:projectsId/locations/:locationsId/applications", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications"

payload = {
    "authDomain": "",
    "codeBucket": "",
    "databaseType": "",
    "defaultBucket": "",
    "defaultCookieExpiration": "",
    "defaultHostname": "",
    "dispatchRules": [
        {
            "domain": "",
            "path": "",
            "service": ""
        }
    ],
    "featureSettings": {
        "splitHealthChecks": False,
        "useContainerOptimizedOs": False
    },
    "gcrDomain": "",
    "iap": {
        "enabled": False,
        "oauth2ClientId": "",
        "oauth2ClientSecret": "",
        "oauth2ClientSecretSha256": ""
    },
    "id": "",
    "locationId": "",
    "name": "",
    "serviceAccount": "",
    "servingStatus": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications"

payload <- "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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}}/v1beta/projects/:projectsId/locations/:locationsId/applications")

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  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\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/v1beta/projects/:projectsId/locations/:locationsId/applications') do |req|
  req.body = "{\n  \"authDomain\": \"\",\n  \"codeBucket\": \"\",\n  \"databaseType\": \"\",\n  \"defaultBucket\": \"\",\n  \"defaultCookieExpiration\": \"\",\n  \"defaultHostname\": \"\",\n  \"dispatchRules\": [\n    {\n      \"domain\": \"\",\n      \"path\": \"\",\n      \"service\": \"\"\n    }\n  ],\n  \"featureSettings\": {\n    \"splitHealthChecks\": false,\n    \"useContainerOptimizedOs\": false\n  },\n  \"gcrDomain\": \"\",\n  \"iap\": {\n    \"enabled\": false,\n    \"oauth2ClientId\": \"\",\n    \"oauth2ClientSecret\": \"\",\n    \"oauth2ClientSecretSha256\": \"\"\n  },\n  \"id\": \"\",\n  \"locationId\": \"\",\n  \"name\": \"\",\n  \"serviceAccount\": \"\",\n  \"servingStatus\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications";

    let payload = json!({
        "authDomain": "",
        "codeBucket": "",
        "databaseType": "",
        "defaultBucket": "",
        "defaultCookieExpiration": "",
        "defaultHostname": "",
        "dispatchRules": (
            json!({
                "domain": "",
                "path": "",
                "service": ""
            })
        ),
        "featureSettings": json!({
            "splitHealthChecks": false,
            "useContainerOptimizedOs": false
        }),
        "gcrDomain": "",
        "iap": json!({
            "enabled": false,
            "oauth2ClientId": "",
            "oauth2ClientSecret": "",
            "oauth2ClientSecretSha256": ""
        }),
        "id": "",
        "locationId": "",
        "name": "",
        "serviceAccount": "",
        "servingStatus": ""
    });

    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}}/v1beta/projects/:projectsId/locations/:locationsId/applications \
  --header 'content-type: application/json' \
  --data '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}'

echo '{
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    {
      "domain": "",
      "path": "",
      "service": ""
    }
  ],
  "featureSettings": {
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  },
  "gcrDomain": "",
  "iap": {
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  },
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
}' |  \
  http POST {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authDomain": "",\n  "codeBucket": "",\n  "databaseType": "",\n  "defaultBucket": "",\n  "defaultCookieExpiration": "",\n  "defaultHostname": "",\n  "dispatchRules": [\n    {\n      "domain": "",\n      "path": "",\n      "service": ""\n    }\n  ],\n  "featureSettings": {\n    "splitHealthChecks": false,\n    "useContainerOptimizedOs": false\n  },\n  "gcrDomain": "",\n  "iap": {\n    "enabled": false,\n    "oauth2ClientId": "",\n    "oauth2ClientSecret": "",\n    "oauth2ClientSecretSha256": ""\n  },\n  "id": "",\n  "locationId": "",\n  "name": "",\n  "serviceAccount": "",\n  "servingStatus": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authDomain": "",
  "codeBucket": "",
  "databaseType": "",
  "defaultBucket": "",
  "defaultCookieExpiration": "",
  "defaultHostname": "",
  "dispatchRules": [
    [
      "domain": "",
      "path": "",
      "service": ""
    ]
  ],
  "featureSettings": [
    "splitHealthChecks": false,
    "useContainerOptimizedOs": false
  ],
  "gcrDomain": "",
  "iap": [
    "enabled": false,
    "oauth2ClientId": "",
    "oauth2ClientSecret": "",
    "oauth2ClientSecretSha256": ""
  ],
  "id": "",
  "locationId": "",
  "name": "",
  "serviceAccount": "",
  "servingStatus": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications")! 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 appengine.projects.locations.applications.get

{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId

QUERY PARAMS

projectsId

locationsId

applicationsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId")

require "http/client"

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId"

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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId"

	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/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId"))
    .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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId")
  .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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId';
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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId',
  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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId');

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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId';
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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId"]
                                                       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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId",
  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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId")

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/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId";

    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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId

http GET {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId")! 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 appengine.projects.locations.applications.repair

{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair

QUERY PARAMS

projectsId

locationsId

applicationsId

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair");

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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair"
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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair"),
    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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair");
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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair"

	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/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair"))
    .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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair")
  .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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair';
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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair',
  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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair")
  .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/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair',
  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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair',
  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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair');

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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair',
  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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair';
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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair"]
                                                       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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair" 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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair",
  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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair');
$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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair');
$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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair' -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/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair"

payload = {}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair"

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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair")

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/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair') 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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair";

    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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair \
  --header 'content-type: application/json' \
  --data '{}'

echo '{}' |  \
  http POST {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair

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}}/v1beta/projects/:projectsId/locations/:locationsId/applications/:applicationsId:repair")! 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 appengine.projects.locations.get

{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId

QUERY PARAMS

projectsId

locationsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId")

require "http/client"

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId"

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}}/v1beta/projects/:projectsId/locations/:locationsId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId"

	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/v1beta/projects/:projectsId/locations/:locationsId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId"))
    .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}}/v1beta/projects/:projectsId/locations/:locationsId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId")
  .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}}/v1beta/projects/:projectsId/locations/:locationsId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId';
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}}/v1beta/projects/:projectsId/locations/:locationsId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/projects/:projectsId/locations/:locationsId',
  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}}/v1beta/projects/:projectsId/locations/:locationsId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId');

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}}/v1beta/projects/:projectsId/locations/:locationsId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId';
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}}/v1beta/projects/:projectsId/locations/:locationsId"]
                                                       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}}/v1beta/projects/:projectsId/locations/:locationsId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId",
  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}}/v1beta/projects/:projectsId/locations/:locationsId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1beta/projects/:projectsId/locations/:locationsId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId")

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/v1beta/projects/:projectsId/locations/:locationsId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId";

    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}}/v1beta/projects/:projectsId/locations/:locationsId

http GET {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId")! 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 appengine.projects.locations.list

{{baseUrl}}/v1beta/projects/:projectsId/locations

QUERY PARAMS

projectsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/projects/:projectsId/locations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1beta/projects/:projectsId/locations")

require "http/client"

url = "{{baseUrl}}/v1beta/projects/:projectsId/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}}/v1beta/projects/:projectsId/locations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/projects/:projectsId/locations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta/projects/:projectsId/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/v1beta/projects/:projectsId/locations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/projects/:projectsId/locations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/projects/:projectsId/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}}/v1beta/projects/:projectsId/locations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/projects/:projectsId/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}}/v1beta/projects/:projectsId/locations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/projects/:projectsId/locations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta/projects/:projectsId/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}}/v1beta/projects/:projectsId/locations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/projects/:projectsId/locations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/projects/:projectsId/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}}/v1beta/projects/:projectsId/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}}/v1beta/projects/:projectsId/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}}/v1beta/projects/:projectsId/locations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta/projects/:projectsId/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}}/v1beta/projects/:projectsId/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}}/v1beta/projects/:projectsId/locations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta/projects/:projectsId/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}}/v1beta/projects/:projectsId/locations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1beta/projects/:projectsId/locations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/projects/:projectsId/locations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/projects/:projectsId/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/v1beta/projects/:projectsId/locations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/projects/:projectsId/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}}/v1beta/projects/:projectsId/locations

http GET {{baseUrl}}/v1beta/projects/:projectsId/locations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/projects/:projectsId/locations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/projects/:projectsId/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()

GET appengine.projects.locations.operations.get

{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId

QUERY PARAMS

projectsId

locationsId

operationsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId")

require "http/client"

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId"

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}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId"

	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/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId"))
    .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}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId")
  .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}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId';
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}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId',
  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}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId');

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}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId';
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}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId"]
                                                       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}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId",
  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}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId")

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/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId";

    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}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId

http GET {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations/:operationsId")! 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 appengine.projects.locations.operations.list

{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations

QUERY PARAMS

projectsId

locationsId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations")

require "http/client"

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations"

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}}/v1beta/projects/:projectsId/locations/:locationsId/operations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations"

	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/v1beta/projects/:projectsId/locations/:locationsId/operations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations"))
    .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}}/v1beta/projects/:projectsId/locations/:locationsId/operations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations")
  .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}}/v1beta/projects/:projectsId/locations/:locationsId/operations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations';
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}}/v1beta/projects/:projectsId/locations/:locationsId/operations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1beta/projects/:projectsId/locations/:locationsId/operations',
  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}}/v1beta/projects/:projectsId/locations/:locationsId/operations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations');

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}}/v1beta/projects/:projectsId/locations/:locationsId/operations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations';
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}}/v1beta/projects/:projectsId/locations/:locationsId/operations"]
                                                       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}}/v1beta/projects/:projectsId/locations/:locationsId/operations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations",
  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}}/v1beta/projects/:projectsId/locations/:locationsId/operations');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1beta/projects/:projectsId/locations/:locationsId/operations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations")

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/v1beta/projects/:projectsId/locations/:locationsId/operations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations";

    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}}/v1beta/projects/:projectsId/locations/:locationsId/operations

http GET {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/projects/:projectsId/locations/:locationsId/operations")! 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()