Google Analytics Admin API

GET analyticsadmin.accounts.list

{{baseUrl}}/v1beta/accounts

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/accounts");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/accounts")

require "http/client"

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

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta/accounts'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/accounts")
  .get()
  .build()

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

const http = require('https');

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

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/accounts');

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/accounts'};

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

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

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

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

 "{{baseUrl}}/v1beta/accounts",
  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/accounts');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/accounts');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/accounts' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/accounts' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/accounts")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/accounts")

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/accounts') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/accounts

http GET {{baseUrl}}/v1beta/accounts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/accounts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/accounts")! 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 analyticsadmin.accounts.provisionAccountTicket

{{baseUrl}}/v1beta/accounts:provisionAccountTicket

BODY json

{
  "account": {
    "createTime": "",
    "deleted": false,
    "displayName": "",
    "name": "",
    "regionCode": "",
    "updateTime": ""
  },
  "redirectUri": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/accounts:provisionAccountTicket");

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  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/accounts:provisionAccountTicket" {:content-type :json
                                                                                   :form-params {:account {:createTime ""
                                                                                                           :deleted false
                                                                                                           :displayName ""
                                                                                                           :name ""
                                                                                                           :regionCode ""
                                                                                                           :updateTime ""}
                                                                                                 :redirectUri ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/accounts:provisionAccountTicket"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\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/accounts:provisionAccountTicket"),
    Content = new StringContent("{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\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/accounts:provisionAccountTicket");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/accounts:provisionAccountTicket"

	payload := strings.NewReader("{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\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/accounts:provisionAccountTicket HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 169

{
  "account": {
    "createTime": "",
    "deleted": false,
    "displayName": "",
    "name": "",
    "regionCode": "",
    "updateTime": ""
  },
  "redirectUri": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/accounts:provisionAccountTicket")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/accounts:provisionAccountTicket"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\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  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/accounts:provisionAccountTicket")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/accounts:provisionAccountTicket")
  .header("content-type", "application/json")
  .body("{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  account: {
    createTime: '',
    deleted: false,
    displayName: '',
    name: '',
    regionCode: '',
    updateTime: ''
  },
  redirectUri: ''
});

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/accounts:provisionAccountTicket');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/accounts:provisionAccountTicket',
  headers: {'content-type': 'application/json'},
  data: {
    account: {
      createTime: '',
      deleted: false,
      displayName: '',
      name: '',
      regionCode: '',
      updateTime: ''
    },
    redirectUri: ''
  }
};

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

const url = '{{baseUrl}}/v1beta/accounts:provisionAccountTicket';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"account":{"createTime":"","deleted":false,"displayName":"","name":"","regionCode":"","updateTime":""},"redirectUri":""}'
};

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/accounts:provisionAccountTicket',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "account": {\n    "createTime": "",\n    "deleted": false,\n    "displayName": "",\n    "name": "",\n    "regionCode": "",\n    "updateTime": ""\n  },\n  "redirectUri": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/accounts:provisionAccountTicket")
  .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/accounts:provisionAccountTicket',
  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({
  account: {
    createTime: '',
    deleted: false,
    displayName: '',
    name: '',
    regionCode: '',
    updateTime: ''
  },
  redirectUri: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/accounts:provisionAccountTicket',
  headers: {'content-type': 'application/json'},
  body: {
    account: {
      createTime: '',
      deleted: false,
      displayName: '',
      name: '',
      regionCode: '',
      updateTime: ''
    },
    redirectUri: ''
  },
  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/accounts:provisionAccountTicket');

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

req.type('json');
req.send({
  account: {
    createTime: '',
    deleted: false,
    displayName: '',
    name: '',
    regionCode: '',
    updateTime: ''
  },
  redirectUri: ''
});

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/accounts:provisionAccountTicket',
  headers: {'content-type': 'application/json'},
  data: {
    account: {
      createTime: '',
      deleted: false,
      displayName: '',
      name: '',
      regionCode: '',
      updateTime: ''
    },
    redirectUri: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta/accounts:provisionAccountTicket';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"account":{"createTime":"","deleted":false,"displayName":"","name":"","regionCode":"","updateTime":""},"redirectUri":""}'
};

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 = @{ @"account": @{ @"createTime": @"", @"deleted": @NO, @"displayName": @"", @"name": @"", @"regionCode": @"", @"updateTime": @"" },
                              @"redirectUri": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/accounts:provisionAccountTicket"]
                                                       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/accounts:provisionAccountTicket" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/accounts:provisionAccountTicket",
  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([
    'account' => [
        'createTime' => '',
        'deleted' => null,
        'displayName' => '',
        'name' => '',
        'regionCode' => '',
        'updateTime' => ''
    ],
    'redirectUri' => ''
  ]),
  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/accounts:provisionAccountTicket', [
  'body' => '{
  "account": {
    "createTime": "",
    "deleted": false,
    "displayName": "",
    "name": "",
    "regionCode": "",
    "updateTime": ""
  },
  "redirectUri": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'account' => [
    'createTime' => '',
    'deleted' => null,
    'displayName' => '',
    'name' => '',
    'regionCode' => '',
    'updateTime' => ''
  ],
  'redirectUri' => ''
]));

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

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

append(json_encode([
  'account' => [
    'createTime' => '',
    'deleted' => null,
    'displayName' => '',
    'name' => '',
    'regionCode' => '',
    'updateTime' => ''
  ],
  'redirectUri' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/accounts:provisionAccountTicket');
$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/accounts:provisionAccountTicket' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "account": {
    "createTime": "",
    "deleted": false,
    "displayName": "",
    "name": "",
    "regionCode": "",
    "updateTime": ""
  },
  "redirectUri": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/accounts:provisionAccountTicket' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "account": {
    "createTime": "",
    "deleted": false,
    "displayName": "",
    "name": "",
    "regionCode": "",
    "updateTime": ""
  },
  "redirectUri": ""
}'

import http.client

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

payload = "{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta/accounts:provisionAccountTicket", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/accounts:provisionAccountTicket"

payload = {
    "account": {
        "createTime": "",
        "deleted": False,
        "displayName": "",
        "name": "",
        "regionCode": "",
        "updateTime": ""
    },
    "redirectUri": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/accounts:provisionAccountTicket"

payload <- "{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\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/accounts:provisionAccountTicket")

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  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\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/accounts:provisionAccountTicket') do |req|
  req.body = "{\n  \"account\": {\n    \"createTime\": \"\",\n    \"deleted\": false,\n    \"displayName\": \"\",\n    \"name\": \"\",\n    \"regionCode\": \"\",\n    \"updateTime\": \"\"\n  },\n  \"redirectUri\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "account": json!({
            "createTime": "",
            "deleted": false,
            "displayName": "",
            "name": "",
            "regionCode": "",
            "updateTime": ""
        }),
        "redirectUri": ""
    });

    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/accounts:provisionAccountTicket \
  --header 'content-type: application/json' \
  --data '{
  "account": {
    "createTime": "",
    "deleted": false,
    "displayName": "",
    "name": "",
    "regionCode": "",
    "updateTime": ""
  },
  "redirectUri": ""
}'

echo '{
  "account": {
    "createTime": "",
    "deleted": false,
    "displayName": "",
    "name": "",
    "regionCode": "",
    "updateTime": ""
  },
  "redirectUri": ""
}' |  \
  http POST {{baseUrl}}/v1beta/accounts:provisionAccountTicket \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "account": {\n    "createTime": "",\n    "deleted": false,\n    "displayName": "",\n    "name": "",\n    "regionCode": "",\n    "updateTime": ""\n  },\n  "redirectUri": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/accounts:provisionAccountTicket

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "account": [
    "createTime": "",
    "deleted": false,
    "displayName": "",
    "name": "",
    "regionCode": "",
    "updateTime": ""
  ],
  "redirectUri": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/accounts:provisionAccountTicket")! 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 analyticsadmin.accounts.searchChangeHistoryEvents

{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents

QUERY PARAMS

account

BODY json

{
  "action": [],
  "actorEmail": [],
  "earliestChangeTime": "",
  "latestChangeTime": "",
  "pageSize": 0,
  "pageToken": "",
  "property": "",
  "resourceType": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents");

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  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents" {:content-type :json
                                                                                      :form-params {:action []
                                                                                                    :actorEmail []
                                                                                                    :earliestChangeTime ""
                                                                                                    :latestChangeTime ""
                                                                                                    :pageSize 0
                                                                                                    :pageToken ""
                                                                                                    :property ""
                                                                                                    :resourceType []}})

require "http/client"

url = "{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\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/:account:searchChangeHistoryEvents"),
    Content = new StringContent("{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents"

	payload := strings.NewReader("{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\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/:account:searchChangeHistoryEvents HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 168

{
  "action": [],
  "actorEmail": [],
  "earliestChangeTime": "",
  "latestChangeTime": "",
  "pageSize": 0,
  "pageToken": "",
  "property": "",
  "resourceType": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents")
  .header("content-type", "application/json")
  .body("{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}")
  .asString();

const data = JSON.stringify({
  action: [],
  actorEmail: [],
  earliestChangeTime: '',
  latestChangeTime: '',
  pageSize: 0,
  pageToken: '',
  property: '',
  resourceType: []
});

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/:account:searchChangeHistoryEvents');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents',
  headers: {'content-type': 'application/json'},
  data: {
    action: [],
    actorEmail: [],
    earliestChangeTime: '',
    latestChangeTime: '',
    pageSize: 0,
    pageToken: '',
    property: '',
    resourceType: []
  }
};

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

const url = '{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"action":[],"actorEmail":[],"earliestChangeTime":"","latestChangeTime":"","pageSize":0,"pageToken":"","property":"","resourceType":[]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "action": [],\n  "actorEmail": [],\n  "earliestChangeTime": "",\n  "latestChangeTime": "",\n  "pageSize": 0,\n  "pageToken": "",\n  "property": "",\n  "resourceType": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents")
  .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/:account:searchChangeHistoryEvents',
  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: [],
  actorEmail: [],
  earliestChangeTime: '',
  latestChangeTime: '',
  pageSize: 0,
  pageToken: '',
  property: '',
  resourceType: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents',
  headers: {'content-type': 'application/json'},
  body: {
    action: [],
    actorEmail: [],
    earliestChangeTime: '',
    latestChangeTime: '',
    pageSize: 0,
    pageToken: '',
    property: '',
    resourceType: []
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents');

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

req.type('json');
req.send({
  action: [],
  actorEmail: [],
  earliestChangeTime: '',
  latestChangeTime: '',
  pageSize: 0,
  pageToken: '',
  property: '',
  resourceType: []
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents',
  headers: {'content-type': 'application/json'},
  data: {
    action: [],
    actorEmail: [],
    earliestChangeTime: '',
    latestChangeTime: '',
    pageSize: 0,
    pageToken: '',
    property: '',
    resourceType: []
  }
};

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

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

const url = '{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"action":[],"actorEmail":[],"earliestChangeTime":"","latestChangeTime":"","pageSize":0,"pageToken":"","property":"","resourceType":[]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"action": @[  ],
                              @"actorEmail": @[  ],
                              @"earliestChangeTime": @"",
                              @"latestChangeTime": @"",
                              @"pageSize": @0,
                              @"pageToken": @"",
                              @"property": @"",
                              @"resourceType": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents"]
                                                       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/:account:searchChangeHistoryEvents" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}" in

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

 "{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents",
  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' => [
        
    ],
    'actorEmail' => [
        
    ],
    'earliestChangeTime' => '',
    'latestChangeTime' => '',
    'pageSize' => 0,
    'pageToken' => '',
    'property' => '',
    'resourceType' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents', [
  'body' => '{
  "action": [],
  "actorEmail": [],
  "earliestChangeTime": "",
  "latestChangeTime": "",
  "pageSize": 0,
  "pageToken": "",
  "property": "",
  "resourceType": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'action' => [
    
  ],
  'actorEmail' => [
    
  ],
  'earliestChangeTime' => '',
  'latestChangeTime' => '',
  'pageSize' => 0,
  'pageToken' => '',
  'property' => '',
  'resourceType' => [
    
  ]
]));

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

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

append(json_encode([
  'action' => [
    
  ],
  'actorEmail' => [
    
  ],
  'earliestChangeTime' => '',
  'latestChangeTime' => '',
  'pageSize' => 0,
  'pageToken' => '',
  'property' => '',
  'resourceType' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents');
$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/:account:searchChangeHistoryEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "action": [],
  "actorEmail": [],
  "earliestChangeTime": "",
  "latestChangeTime": "",
  "pageSize": 0,
  "pageToken": "",
  "property": "",
  "resourceType": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "action": [],
  "actorEmail": [],
  "earliestChangeTime": "",
  "latestChangeTime": "",
  "pageSize": 0,
  "pageToken": "",
  "property": "",
  "resourceType": []
}'

import http.client

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

payload = "{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}"

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

conn.request("POST", "/baseUrl/v1beta/:account:searchChangeHistoryEvents", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents"

payload = {
    "action": [],
    "actorEmail": [],
    "earliestChangeTime": "",
    "latestChangeTime": "",
    "pageSize": 0,
    "pageToken": "",
    "property": "",
    "resourceType": []
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents"

payload <- "{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\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/:account:searchChangeHistoryEvents")

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  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1beta/:account:searchChangeHistoryEvents') do |req|
  req.body = "{\n  \"action\": [],\n  \"actorEmail\": [],\n  \"earliestChangeTime\": \"\",\n  \"latestChangeTime\": \"\",\n  \"pageSize\": 0,\n  \"pageToken\": \"\",\n  \"property\": \"\",\n  \"resourceType\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "action": (),
        "actorEmail": (),
        "earliestChangeTime": "",
        "latestChangeTime": "",
        "pageSize": 0,
        "pageToken": "",
        "property": "",
        "resourceType": ()
    });

    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/:account:searchChangeHistoryEvents \
  --header 'content-type: application/json' \
  --data '{
  "action": [],
  "actorEmail": [],
  "earliestChangeTime": "",
  "latestChangeTime": "",
  "pageSize": 0,
  "pageToken": "",
  "property": "",
  "resourceType": []
}'

echo '{
  "action": [],
  "actorEmail": [],
  "earliestChangeTime": "",
  "latestChangeTime": "",
  "pageSize": 0,
  "pageToken": "",
  "property": "",
  "resourceType": []
}' |  \
  http POST {{baseUrl}}/v1beta/:account:searchChangeHistoryEvents \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "action": [],\n  "actorEmail": [],\n  "earliestChangeTime": "",\n  "latestChangeTime": "",\n  "pageSize": 0,\n  "pageToken": "",\n  "property": "",\n  "resourceType": []\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/:account:searchChangeHistoryEvents

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "action": [],
  "actorEmail": [],
  "earliestChangeTime": "",
  "latestChangeTime": "",
  "pageSize": 0,
  "pageToken": "",
  "property": "",
  "resourceType": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:account:searchChangeHistoryEvents")! 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 analyticsadmin.accountSummaries.list

{{baseUrl}}/v1beta/accountSummaries

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/accountSummaries");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/accountSummaries")

require "http/client"

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

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta/accountSummaries'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/accountSummaries")
  .get()
  .build()

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

const http = require('https');

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

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/accountSummaries');

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/accountSummaries'};

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

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

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

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

 "{{baseUrl}}/v1beta/accountSummaries",
  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/accountSummaries');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/accountSummaries');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/accountSummaries' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/accountSummaries' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/accountSummaries")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/accountSummaries")

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/accountSummaries') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/accountSummaries

http GET {{baseUrl}}/v1beta/accountSummaries

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/accountSummaries

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/accountSummaries")! 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 analyticsadmin.properties.acknowledgeUserDataCollection

{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection

QUERY PARAMS

property

BODY json

{
  "acknowledgement": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection");

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  \"acknowledgement\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection" {:content-type :json
                                                                                           :form-params {:acknowledgement ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"acknowledgement\": \"\"\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/:property:acknowledgeUserDataCollection"),
    Content = new StringContent("{\n  \"acknowledgement\": \"\"\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/:property:acknowledgeUserDataCollection");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"acknowledgement\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection"

	payload := strings.NewReader("{\n  \"acknowledgement\": \"\"\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/:property:acknowledgeUserDataCollection HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 27

{
  "acknowledgement": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"acknowledgement\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection")
  .header("content-type", "application/json")
  .body("{\n  \"acknowledgement\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  acknowledgement: ''
});

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/:property:acknowledgeUserDataCollection');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection',
  headers: {'content-type': 'application/json'},
  data: {acknowledgement: ''}
};

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

const url = '{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"acknowledgement":""}'
};

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/:property:acknowledgeUserDataCollection',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "acknowledgement": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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/:property:acknowledgeUserDataCollection',
  headers: {'content-type': 'application/json'},
  data: {acknowledgement: ''}
};

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

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

const url = '{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"acknowledgement":""}'
};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'acknowledgement' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection');
$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/:property:acknowledgeUserDataCollection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "acknowledgement": ""
}'

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

import http.client

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

payload = "{\n  \"acknowledgement\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta/:property:acknowledgeUserDataCollection", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection"

payload <- "{\n  \"acknowledgement\": \"\"\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/:property:acknowledgeUserDataCollection")

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  \"acknowledgement\": \"\"\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/:property:acknowledgeUserDataCollection') do |req|
  req.body = "{\n  \"acknowledgement\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"acknowledgement": ""});

    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/:property:acknowledgeUserDataCollection \
  --header 'content-type: application/json' \
  --data '{
  "acknowledgement": ""
}'

echo '{
  "acknowledgement": ""
}' |  \
  http POST {{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "acknowledgement": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:property:acknowledgeUserDataCollection")! 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 analyticsadmin.properties.conversionEvents.create

{{baseUrl}}/v1beta/:parent/conversionEvents

QUERY PARAMS

parent

BODY json

{
  "createTime": "",
  "custom": false,
  "deletable": false,
  "eventName": "",
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/:parent/conversionEvents" {:content-type :json
                                                                            :form-params {:createTime ""
                                                                                          :custom false
                                                                                          :deletable false
                                                                                          :eventName ""
                                                                                          :name ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/conversionEvents"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1beta/:parent/conversionEvents"),
    Content = new StringContent("{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/:parent/conversionEvents");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/conversionEvents"

	payload := strings.NewReader("{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/v1beta/:parent/conversionEvents HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 96

{
  "createTime": "",
  "custom": false,
  "deletable": false,
  "eventName": "",
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/:parent/conversionEvents")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/:parent/conversionEvents"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/:parent/conversionEvents")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/:parent/conversionEvents")
  .header("content-type", "application/json")
  .body("{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  createTime: '',
  custom: false,
  deletable: false,
  eventName: '',
  name: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/conversionEvents',
  headers: {'content-type': 'application/json'},
  data: {createTime: '', custom: false, deletable: false, eventName: '', name: ''}
};

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

const url = '{{baseUrl}}/v1beta/:parent/conversionEvents';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"createTime":"","custom":false,"deletable":false,"eventName":"","name":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1beta/:parent/conversionEvents',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "createTime": "",\n  "custom": false,\n  "deletable": false,\n  "eventName": "",\n  "name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/:parent/conversionEvents")
  .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/:parent/conversionEvents',
  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({createTime: '', custom: false, deletable: false, eventName: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/conversionEvents',
  headers: {'content-type': 'application/json'},
  body: {createTime: '', custom: false, deletable: false, eventName: '', name: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1beta/:parent/conversionEvents');

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

req.type('json');
req.send({
  createTime: '',
  custom: false,
  deletable: false,
  eventName: '',
  name: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/conversionEvents',
  headers: {'content-type': 'application/json'},
  data: {createTime: '', custom: false, deletable: false, eventName: '', name: ''}
};

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

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

const url = '{{baseUrl}}/v1beta/:parent/conversionEvents';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"createTime":"","custom":false,"deletable":false,"eventName":"","name":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"createTime": @"",
                              @"custom": @NO,
                              @"deletable": @NO,
                              @"eventName": @"",
                              @"name": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/:parent/conversionEvents"]
                                                       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/:parent/conversionEvents" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/:parent/conversionEvents",
  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([
    'createTime' => '',
    'custom' => null,
    'deletable' => null,
    'eventName' => '',
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v1beta/:parent/conversionEvents', [
  'body' => '{
  "createTime": "",
  "custom": false,
  "deletable": false,
  "eventName": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'createTime' => '',
  'custom' => null,
  'deletable' => null,
  'eventName' => '',
  'name' => ''
]));

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

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

append(json_encode([
  'createTime' => '',
  'custom' => null,
  'deletable' => null,
  'eventName' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/:parent/conversionEvents');
$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/:parent/conversionEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "createTime": "",
  "custom": false,
  "deletable": false,
  "eventName": "",
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/:parent/conversionEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "createTime": "",
  "custom": false,
  "deletable": false,
  "eventName": "",
  "name": ""
}'

import http.client

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

payload = "{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta/:parent/conversionEvents", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/conversionEvents"

payload = {
    "createTime": "",
    "custom": False,
    "deletable": False,
    "eventName": "",
    "name": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/conversionEvents"

payload <- "{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/:parent/conversionEvents")

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  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v1beta/:parent/conversionEvents') do |req|
  req.body = "{\n  \"createTime\": \"\",\n  \"custom\": false,\n  \"deletable\": false,\n  \"eventName\": \"\",\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "createTime": "",
        "custom": false,
        "deletable": false,
        "eventName": "",
        "name": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1beta/:parent/conversionEvents \
  --header 'content-type: application/json' \
  --data '{
  "createTime": "",
  "custom": false,
  "deletable": false,
  "eventName": "",
  "name": ""
}'

echo '{
  "createTime": "",
  "custom": false,
  "deletable": false,
  "eventName": "",
  "name": ""
}' |  \
  http POST {{baseUrl}}/v1beta/:parent/conversionEvents \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "createTime": "",\n  "custom": false,\n  "deletable": false,\n  "eventName": "",\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/conversionEvents

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "createTime": "",
  "custom": false,
  "deletable": false,
  "eventName": "",
  "name": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/conversionEvents")! 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 analyticsadmin.properties.conversionEvents.list

{{baseUrl}}/v1beta/:parent/conversionEvents

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/:parent/conversionEvents")

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/conversionEvents"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/conversionEvents"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/:parent/conversionEvents'
};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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/:parent/conversionEvents');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1beta/:parent/conversionEvents")

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/conversionEvents"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/conversionEvents"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/:parent/conversionEvents")

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

puts response.status
puts response.body

use reqwest;

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

    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/:parent/conversionEvents

http GET {{baseUrl}}/v1beta/:parent/conversionEvents

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/conversionEvents

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/conversionEvents")! 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 analyticsadmin.properties.create

{{baseUrl}}/v1beta/properties

BODY json

{
  "account": "",
  "createTime": "",
  "currencyCode": "",
  "deleteTime": "",
  "displayName": "",
  "expireTime": "",
  "industryCategory": "",
  "name": "",
  "parent": "",
  "propertyType": "",
  "serviceLevel": "",
  "timeZone": "",
  "updateTime": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/properties" {:content-type :json
                                                              :form-params {:account ""
                                                                            :createTime ""
                                                                            :currencyCode ""
                                                                            :deleteTime ""
                                                                            :displayName ""
                                                                            :expireTime ""
                                                                            :industryCategory ""
                                                                            :name ""
                                                                            :parent ""
                                                                            :propertyType ""
                                                                            :serviceLevel ""
                                                                            :timeZone ""
                                                                            :updateTime ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/properties"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\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/properties"),
    Content = new StringContent("{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\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/properties");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\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/properties HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 260

{
  "account": "",
  "createTime": "",
  "currencyCode": "",
  "deleteTime": "",
  "displayName": "",
  "expireTime": "",
  "industryCategory": "",
  "name": "",
  "parent": "",
  "propertyType": "",
  "serviceLevel": "",
  "timeZone": "",
  "updateTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/properties")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/properties"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\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  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/properties")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/properties")
  .header("content-type", "application/json")
  .body("{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  account: '',
  createTime: '',
  currencyCode: '',
  deleteTime: '',
  displayName: '',
  expireTime: '',
  industryCategory: '',
  name: '',
  parent: '',
  propertyType: '',
  serviceLevel: '',
  timeZone: '',
  updateTime: ''
});

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/properties');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/properties',
  headers: {'content-type': 'application/json'},
  data: {
    account: '',
    createTime: '',
    currencyCode: '',
    deleteTime: '',
    displayName: '',
    expireTime: '',
    industryCategory: '',
    name: '',
    parent: '',
    propertyType: '',
    serviceLevel: '',
    timeZone: '',
    updateTime: ''
  }
};

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

const url = '{{baseUrl}}/v1beta/properties';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"account":"","createTime":"","currencyCode":"","deleteTime":"","displayName":"","expireTime":"","industryCategory":"","name":"","parent":"","propertyType":"","serviceLevel":"","timeZone":"","updateTime":""}'
};

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/properties',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "account": "",\n  "createTime": "",\n  "currencyCode": "",\n  "deleteTime": "",\n  "displayName": "",\n  "expireTime": "",\n  "industryCategory": "",\n  "name": "",\n  "parent": "",\n  "propertyType": "",\n  "serviceLevel": "",\n  "timeZone": "",\n  "updateTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/properties")
  .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/properties',
  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({
  account: '',
  createTime: '',
  currencyCode: '',
  deleteTime: '',
  displayName: '',
  expireTime: '',
  industryCategory: '',
  name: '',
  parent: '',
  propertyType: '',
  serviceLevel: '',
  timeZone: '',
  updateTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/properties',
  headers: {'content-type': 'application/json'},
  body: {
    account: '',
    createTime: '',
    currencyCode: '',
    deleteTime: '',
    displayName: '',
    expireTime: '',
    industryCategory: '',
    name: '',
    parent: '',
    propertyType: '',
    serviceLevel: '',
    timeZone: '',
    updateTime: ''
  },
  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/properties');

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

req.type('json');
req.send({
  account: '',
  createTime: '',
  currencyCode: '',
  deleteTime: '',
  displayName: '',
  expireTime: '',
  industryCategory: '',
  name: '',
  parent: '',
  propertyType: '',
  serviceLevel: '',
  timeZone: '',
  updateTime: ''
});

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/properties',
  headers: {'content-type': 'application/json'},
  data: {
    account: '',
    createTime: '',
    currencyCode: '',
    deleteTime: '',
    displayName: '',
    expireTime: '',
    industryCategory: '',
    name: '',
    parent: '',
    propertyType: '',
    serviceLevel: '',
    timeZone: '',
    updateTime: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta/properties';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"account":"","createTime":"","currencyCode":"","deleteTime":"","displayName":"","expireTime":"","industryCategory":"","name":"","parent":"","propertyType":"","serviceLevel":"","timeZone":"","updateTime":""}'
};

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 = @{ @"account": @"",
                              @"createTime": @"",
                              @"currencyCode": @"",
                              @"deleteTime": @"",
                              @"displayName": @"",
                              @"expireTime": @"",
                              @"industryCategory": @"",
                              @"name": @"",
                              @"parent": @"",
                              @"propertyType": @"",
                              @"serviceLevel": @"",
                              @"timeZone": @"",
                              @"updateTime": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/properties"]
                                                       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/properties" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/properties",
  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([
    'account' => '',
    'createTime' => '',
    'currencyCode' => '',
    'deleteTime' => '',
    'displayName' => '',
    'expireTime' => '',
    'industryCategory' => '',
    'name' => '',
    'parent' => '',
    'propertyType' => '',
    'serviceLevel' => '',
    'timeZone' => '',
    'updateTime' => ''
  ]),
  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/properties', [
  'body' => '{
  "account": "",
  "createTime": "",
  "currencyCode": "",
  "deleteTime": "",
  "displayName": "",
  "expireTime": "",
  "industryCategory": "",
  "name": "",
  "parent": "",
  "propertyType": "",
  "serviceLevel": "",
  "timeZone": "",
  "updateTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'account' => '',
  'createTime' => '',
  'currencyCode' => '',
  'deleteTime' => '',
  'displayName' => '',
  'expireTime' => '',
  'industryCategory' => '',
  'name' => '',
  'parent' => '',
  'propertyType' => '',
  'serviceLevel' => '',
  'timeZone' => '',
  'updateTime' => ''
]));

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

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

append(json_encode([
  'account' => '',
  'createTime' => '',
  'currencyCode' => '',
  'deleteTime' => '',
  'displayName' => '',
  'expireTime' => '',
  'industryCategory' => '',
  'name' => '',
  'parent' => '',
  'propertyType' => '',
  'serviceLevel' => '',
  'timeZone' => '',
  'updateTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/properties');
$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/properties' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "account": "",
  "createTime": "",
  "currencyCode": "",
  "deleteTime": "",
  "displayName": "",
  "expireTime": "",
  "industryCategory": "",
  "name": "",
  "parent": "",
  "propertyType": "",
  "serviceLevel": "",
  "timeZone": "",
  "updateTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/properties' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "account": "",
  "createTime": "",
  "currencyCode": "",
  "deleteTime": "",
  "displayName": "",
  "expireTime": "",
  "industryCategory": "",
  "name": "",
  "parent": "",
  "propertyType": "",
  "serviceLevel": "",
  "timeZone": "",
  "updateTime": ""
}'

import http.client

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

payload = "{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\n}"

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

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

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

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

import requests

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

payload = {
    "account": "",
    "createTime": "",
    "currencyCode": "",
    "deleteTime": "",
    "displayName": "",
    "expireTime": "",
    "industryCategory": "",
    "name": "",
    "parent": "",
    "propertyType": "",
    "serviceLevel": "",
    "timeZone": "",
    "updateTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\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/properties")

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  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\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/properties') do |req|
  req.body = "{\n  \"account\": \"\",\n  \"createTime\": \"\",\n  \"currencyCode\": \"\",\n  \"deleteTime\": \"\",\n  \"displayName\": \"\",\n  \"expireTime\": \"\",\n  \"industryCategory\": \"\",\n  \"name\": \"\",\n  \"parent\": \"\",\n  \"propertyType\": \"\",\n  \"serviceLevel\": \"\",\n  \"timeZone\": \"\",\n  \"updateTime\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "account": "",
        "createTime": "",
        "currencyCode": "",
        "deleteTime": "",
        "displayName": "",
        "expireTime": "",
        "industryCategory": "",
        "name": "",
        "parent": "",
        "propertyType": "",
        "serviceLevel": "",
        "timeZone": "",
        "updateTime": ""
    });

    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/properties \
  --header 'content-type: application/json' \
  --data '{
  "account": "",
  "createTime": "",
  "currencyCode": "",
  "deleteTime": "",
  "displayName": "",
  "expireTime": "",
  "industryCategory": "",
  "name": "",
  "parent": "",
  "propertyType": "",
  "serviceLevel": "",
  "timeZone": "",
  "updateTime": ""
}'

echo '{
  "account": "",
  "createTime": "",
  "currencyCode": "",
  "deleteTime": "",
  "displayName": "",
  "expireTime": "",
  "industryCategory": "",
  "name": "",
  "parent": "",
  "propertyType": "",
  "serviceLevel": "",
  "timeZone": "",
  "updateTime": ""
}' |  \
  http POST {{baseUrl}}/v1beta/properties \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "account": "",\n  "createTime": "",\n  "currencyCode": "",\n  "deleteTime": "",\n  "displayName": "",\n  "expireTime": "",\n  "industryCategory": "",\n  "name": "",\n  "parent": "",\n  "propertyType": "",\n  "serviceLevel": "",\n  "timeZone": "",\n  "updateTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/properties

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "account": "",
  "createTime": "",
  "currencyCode": "",
  "deleteTime": "",
  "displayName": "",
  "expireTime": "",
  "industryCategory": "",
  "name": "",
  "parent": "",
  "propertyType": "",
  "serviceLevel": "",
  "timeZone": "",
  "updateTime": ""
] as [String : Any]

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

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

{{baseUrl}}/v1beta/:parent/customDimensions

QUERY PARAMS

parent

BODY json

{
  "description": "",
  "disallowAdsPersonalization": false,
  "displayName": "",
  "name": "",
  "parameterName": "",
  "scope": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/:parent/customDimensions" {:content-type :json
                                                                            :form-params {:description ""
                                                                                          :disallowAdsPersonalization false
                                                                                          :displayName ""
                                                                                          :name ""
                                                                                          :parameterName ""
                                                                                          :scope ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/customDimensions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\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/:parent/customDimensions"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\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/:parent/customDimensions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/customDimensions"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\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/:parent/customDimensions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 135

{
  "description": "",
  "disallowAdsPersonalization": false,
  "displayName": "",
  "name": "",
  "parameterName": "",
  "scope": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/:parent/customDimensions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/:parent/customDimensions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\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  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/:parent/customDimensions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/:parent/customDimensions")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  disallowAdsPersonalization: false,
  displayName: '',
  name: '',
  parameterName: '',
  scope: ''
});

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/:parent/customDimensions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/customDimensions',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    disallowAdsPersonalization: false,
    displayName: '',
    name: '',
    parameterName: '',
    scope: ''
  }
};

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

const url = '{{baseUrl}}/v1beta/:parent/customDimensions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","disallowAdsPersonalization":false,"displayName":"","name":"","parameterName":"","scope":""}'
};

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/:parent/customDimensions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "disallowAdsPersonalization": false,\n  "displayName": "",\n  "name": "",\n  "parameterName": "",\n  "scope": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/:parent/customDimensions")
  .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/:parent/customDimensions',
  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({
  description: '',
  disallowAdsPersonalization: false,
  displayName: '',
  name: '',
  parameterName: '',
  scope: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/customDimensions',
  headers: {'content-type': 'application/json'},
  body: {
    description: '',
    disallowAdsPersonalization: false,
    displayName: '',
    name: '',
    parameterName: '',
    scope: ''
  },
  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/:parent/customDimensions');

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

req.type('json');
req.send({
  description: '',
  disallowAdsPersonalization: false,
  displayName: '',
  name: '',
  parameterName: '',
  scope: ''
});

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/:parent/customDimensions',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    disallowAdsPersonalization: false,
    displayName: '',
    name: '',
    parameterName: '',
    scope: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta/:parent/customDimensions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","disallowAdsPersonalization":false,"displayName":"","name":"","parameterName":"","scope":""}'
};

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 = @{ @"description": @"",
                              @"disallowAdsPersonalization": @NO,
                              @"displayName": @"",
                              @"name": @"",
                              @"parameterName": @"",
                              @"scope": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/:parent/customDimensions"]
                                                       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/:parent/customDimensions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/:parent/customDimensions",
  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([
    'description' => '',
    'disallowAdsPersonalization' => null,
    'displayName' => '',
    'name' => '',
    'parameterName' => '',
    'scope' => ''
  ]),
  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/:parent/customDimensions', [
  'body' => '{
  "description": "",
  "disallowAdsPersonalization": false,
  "displayName": "",
  "name": "",
  "parameterName": "",
  "scope": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'disallowAdsPersonalization' => null,
  'displayName' => '',
  'name' => '',
  'parameterName' => '',
  'scope' => ''
]));

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

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

append(json_encode([
  'description' => '',
  'disallowAdsPersonalization' => null,
  'displayName' => '',
  'name' => '',
  'parameterName' => '',
  'scope' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/:parent/customDimensions');
$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/:parent/customDimensions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "disallowAdsPersonalization": false,
  "displayName": "",
  "name": "",
  "parameterName": "",
  "scope": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/:parent/customDimensions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "disallowAdsPersonalization": false,
  "displayName": "",
  "name": "",
  "parameterName": "",
  "scope": ""
}'

import http.client

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

payload = "{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta/:parent/customDimensions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/customDimensions"

payload = {
    "description": "",
    "disallowAdsPersonalization": False,
    "displayName": "",
    "name": "",
    "parameterName": "",
    "scope": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/customDimensions"

payload <- "{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\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/:parent/customDimensions")

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  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\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/:parent/customDimensions') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"disallowAdsPersonalization\": false,\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"scope\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "description": "",
        "disallowAdsPersonalization": false,
        "displayName": "",
        "name": "",
        "parameterName": "",
        "scope": ""
    });

    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/:parent/customDimensions \
  --header 'content-type: application/json' \
  --data '{
  "description": "",
  "disallowAdsPersonalization": false,
  "displayName": "",
  "name": "",
  "parameterName": "",
  "scope": ""
}'

echo '{
  "description": "",
  "disallowAdsPersonalization": false,
  "displayName": "",
  "name": "",
  "parameterName": "",
  "scope": ""
}' |  \
  http POST {{baseUrl}}/v1beta/:parent/customDimensions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "disallowAdsPersonalization": false,\n  "displayName": "",\n  "name": "",\n  "parameterName": "",\n  "scope": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/customDimensions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "disallowAdsPersonalization": false,
  "displayName": "",
  "name": "",
  "parameterName": "",
  "scope": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/customDimensions")! 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 analyticsadmin.properties.customDimensions.list

{{baseUrl}}/v1beta/:parent/customDimensions

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/:parent/customDimensions")

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/customDimensions"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/customDimensions"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/:parent/customDimensions'
};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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/:parent/customDimensions');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1beta/:parent/customDimensions")

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/customDimensions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/customDimensions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/:parent/customDimensions")

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

puts response.status
puts response.body

use reqwest;

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

    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/:parent/customDimensions

http GET {{baseUrl}}/v1beta/:parent/customDimensions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/customDimensions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/customDimensions")! 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 analyticsadmin.properties.customMetrics.archive

{{baseUrl}}/v1beta/:name:archive

QUERY PARAMS

name

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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/:name:archive" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/v1beta/:name:archive"
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/:name:archive"),
    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/:name:archive");
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/:name:archive"

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

{}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/:name:archive"))
    .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/:name:archive")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/:name:archive")
  .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/:name:archive');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:name:archive',
  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/:name:archive';
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/:name:archive',
  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/:name:archive")
  .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/:name:archive',
  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/:name:archive',
  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/:name:archive');

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

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/:name:archive');
$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/:name:archive');
$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/:name:archive' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/:name:archive' -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/:name:archive", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/:name:archive"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:name:archive"

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/:name:archive")

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/:name:archive') 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/:name:archive";

    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/:name:archive \
  --header 'content-type: application/json' \
  --data '{}'

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

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

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/:name:archive")! 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 analyticsadmin.properties.customMetrics.create

{{baseUrl}}/v1beta/:parent/customMetrics

QUERY PARAMS

parent

BODY json

{
  "description": "",
  "displayName": "",
  "measurementUnit": "",
  "name": "",
  "parameterName": "",
  "restrictedMetricType": [],
  "scope": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/:parent/customMetrics" {:content-type :json
                                                                         :form-params {:description ""
                                                                                       :displayName ""
                                                                                       :measurementUnit ""
                                                                                       :name ""
                                                                                       :parameterName ""
                                                                                       :restrictedMetricType []
                                                                                       :scope ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/customMetrics"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\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/:parent/customMetrics"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\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/:parent/customMetrics");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/customMetrics"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\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/:parent/customMetrics HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 151

{
  "description": "",
  "displayName": "",
  "measurementUnit": "",
  "name": "",
  "parameterName": "",
  "restrictedMetricType": [],
  "scope": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/:parent/customMetrics")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/:parent/customMetrics"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\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  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/:parent/customMetrics")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/:parent/customMetrics")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  displayName: '',
  measurementUnit: '',
  name: '',
  parameterName: '',
  restrictedMetricType: [],
  scope: ''
});

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/:parent/customMetrics');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/customMetrics',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    displayName: '',
    measurementUnit: '',
    name: '',
    parameterName: '',
    restrictedMetricType: [],
    scope: ''
  }
};

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

const url = '{{baseUrl}}/v1beta/:parent/customMetrics';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","displayName":"","measurementUnit":"","name":"","parameterName":"","restrictedMetricType":[],"scope":""}'
};

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/:parent/customMetrics',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "displayName": "",\n  "measurementUnit": "",\n  "name": "",\n  "parameterName": "",\n  "restrictedMetricType": [],\n  "scope": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/:parent/customMetrics")
  .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/:parent/customMetrics',
  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({
  description: '',
  displayName: '',
  measurementUnit: '',
  name: '',
  parameterName: '',
  restrictedMetricType: [],
  scope: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/customMetrics',
  headers: {'content-type': 'application/json'},
  body: {
    description: '',
    displayName: '',
    measurementUnit: '',
    name: '',
    parameterName: '',
    restrictedMetricType: [],
    scope: ''
  },
  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/:parent/customMetrics');

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

req.type('json');
req.send({
  description: '',
  displayName: '',
  measurementUnit: '',
  name: '',
  parameterName: '',
  restrictedMetricType: [],
  scope: ''
});

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/:parent/customMetrics',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    displayName: '',
    measurementUnit: '',
    name: '',
    parameterName: '',
    restrictedMetricType: [],
    scope: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta/:parent/customMetrics';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","displayName":"","measurementUnit":"","name":"","parameterName":"","restrictedMetricType":[],"scope":""}'
};

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 = @{ @"description": @"",
                              @"displayName": @"",
                              @"measurementUnit": @"",
                              @"name": @"",
                              @"parameterName": @"",
                              @"restrictedMetricType": @[  ],
                              @"scope": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/:parent/customMetrics"]
                                                       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/:parent/customMetrics" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/:parent/customMetrics",
  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([
    'description' => '',
    'displayName' => '',
    'measurementUnit' => '',
    'name' => '',
    'parameterName' => '',
    'restrictedMetricType' => [
        
    ],
    'scope' => ''
  ]),
  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/:parent/customMetrics', [
  'body' => '{
  "description": "",
  "displayName": "",
  "measurementUnit": "",
  "name": "",
  "parameterName": "",
  "restrictedMetricType": [],
  "scope": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'displayName' => '',
  'measurementUnit' => '',
  'name' => '',
  'parameterName' => '',
  'restrictedMetricType' => [
    
  ],
  'scope' => ''
]));

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

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

append(json_encode([
  'description' => '',
  'displayName' => '',
  'measurementUnit' => '',
  'name' => '',
  'parameterName' => '',
  'restrictedMetricType' => [
    
  ],
  'scope' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/:parent/customMetrics');
$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/:parent/customMetrics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "displayName": "",
  "measurementUnit": "",
  "name": "",
  "parameterName": "",
  "restrictedMetricType": [],
  "scope": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/:parent/customMetrics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "displayName": "",
  "measurementUnit": "",
  "name": "",
  "parameterName": "",
  "restrictedMetricType": [],
  "scope": ""
}'

import http.client

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

payload = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta/:parent/customMetrics", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/customMetrics"

payload = {
    "description": "",
    "displayName": "",
    "measurementUnit": "",
    "name": "",
    "parameterName": "",
    "restrictedMetricType": [],
    "scope": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/customMetrics"

payload <- "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\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/:parent/customMetrics")

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  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\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/:parent/customMetrics') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"measurementUnit\": \"\",\n  \"name\": \"\",\n  \"parameterName\": \"\",\n  \"restrictedMetricType\": [],\n  \"scope\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "description": "",
        "displayName": "",
        "measurementUnit": "",
        "name": "",
        "parameterName": "",
        "restrictedMetricType": (),
        "scope": ""
    });

    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/:parent/customMetrics \
  --header 'content-type: application/json' \
  --data '{
  "description": "",
  "displayName": "",
  "measurementUnit": "",
  "name": "",
  "parameterName": "",
  "restrictedMetricType": [],
  "scope": ""
}'

echo '{
  "description": "",
  "displayName": "",
  "measurementUnit": "",
  "name": "",
  "parameterName": "",
  "restrictedMetricType": [],
  "scope": ""
}' |  \
  http POST {{baseUrl}}/v1beta/:parent/customMetrics \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "displayName": "",\n  "measurementUnit": "",\n  "name": "",\n  "parameterName": "",\n  "restrictedMetricType": [],\n  "scope": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/customMetrics

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "displayName": "",
  "measurementUnit": "",
  "name": "",
  "parameterName": "",
  "restrictedMetricType": [],
  "scope": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/customMetrics")! 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 analyticsadmin.properties.customMetrics.list

{{baseUrl}}/v1beta/:parent/customMetrics

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/:parent/customMetrics")

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/customMetrics"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/customMetrics"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta/:parent/customMetrics'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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/:parent/customMetrics');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1beta/:parent/customMetrics")

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/customMetrics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/customMetrics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/:parent/customMetrics")

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

puts response.status
puts response.body

use reqwest;

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

    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/:parent/customMetrics

http GET {{baseUrl}}/v1beta/:parent/customMetrics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/customMetrics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/customMetrics")! 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 analyticsadmin.properties.dataStreams.create

{{baseUrl}}/v1beta/:parent/dataStreams

QUERY PARAMS

parent

BODY json

{
  "androidAppStreamData": {
    "firebaseAppId": "",
    "packageName": ""
  },
  "createTime": "",
  "displayName": "",
  "iosAppStreamData": {
    "bundleId": "",
    "firebaseAppId": ""
  },
  "name": "",
  "type": "",
  "updateTime": "",
  "webStreamData": {
    "defaultUri": "",
    "firebaseAppId": "",
    "measurementId": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/:parent/dataStreams" {:content-type :json
                                                                       :form-params {:androidAppStreamData {:firebaseAppId ""
                                                                                                            :packageName ""}
                                                                                     :createTime ""
                                                                                     :displayName ""
                                                                                     :iosAppStreamData {:bundleId ""
                                                                                                        :firebaseAppId ""}
                                                                                     :name ""
                                                                                     :type ""
                                                                                     :updateTime ""
                                                                                     :webStreamData {:defaultUri ""
                                                                                                     :firebaseAppId ""
                                                                                                     :measurementId ""}}})

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/dataStreams"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\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/:parent/dataStreams"),
    Content = new StringContent("{\n  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\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/:parent/dataStreams");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/dataStreams"

	payload := strings.NewReader("{\n  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\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/:parent/dataStreams HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 341

{
  "androidAppStreamData": {
    "firebaseAppId": "",
    "packageName": ""
  },
  "createTime": "",
  "displayName": "",
  "iosAppStreamData": {
    "bundleId": "",
    "firebaseAppId": ""
  },
  "name": "",
  "type": "",
  "updateTime": "",
  "webStreamData": {
    "defaultUri": "",
    "firebaseAppId": "",
    "measurementId": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/:parent/dataStreams")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/:parent/dataStreams"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\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  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/:parent/dataStreams")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/:parent/dataStreams")
  .header("content-type", "application/json")
  .body("{\n  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  androidAppStreamData: {
    firebaseAppId: '',
    packageName: ''
  },
  createTime: '',
  displayName: '',
  iosAppStreamData: {
    bundleId: '',
    firebaseAppId: ''
  },
  name: '',
  type: '',
  updateTime: '',
  webStreamData: {
    defaultUri: '',
    firebaseAppId: '',
    measurementId: ''
  }
});

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/:parent/dataStreams');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/dataStreams',
  headers: {'content-type': 'application/json'},
  data: {
    androidAppStreamData: {firebaseAppId: '', packageName: ''},
    createTime: '',
    displayName: '',
    iosAppStreamData: {bundleId: '', firebaseAppId: ''},
    name: '',
    type: '',
    updateTime: '',
    webStreamData: {defaultUri: '', firebaseAppId: '', measurementId: ''}
  }
};

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

const url = '{{baseUrl}}/v1beta/:parent/dataStreams';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"androidAppStreamData":{"firebaseAppId":"","packageName":""},"createTime":"","displayName":"","iosAppStreamData":{"bundleId":"","firebaseAppId":""},"name":"","type":"","updateTime":"","webStreamData":{"defaultUri":"","firebaseAppId":"","measurementId":""}}'
};

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/:parent/dataStreams',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "androidAppStreamData": {\n    "firebaseAppId": "",\n    "packageName": ""\n  },\n  "createTime": "",\n  "displayName": "",\n  "iosAppStreamData": {\n    "bundleId": "",\n    "firebaseAppId": ""\n  },\n  "name": "",\n  "type": "",\n  "updateTime": "",\n  "webStreamData": {\n    "defaultUri": "",\n    "firebaseAppId": "",\n    "measurementId": ""\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  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/:parent/dataStreams")
  .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/:parent/dataStreams',
  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({
  androidAppStreamData: {firebaseAppId: '', packageName: ''},
  createTime: '',
  displayName: '',
  iosAppStreamData: {bundleId: '', firebaseAppId: ''},
  name: '',
  type: '',
  updateTime: '',
  webStreamData: {defaultUri: '', firebaseAppId: '', measurementId: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/dataStreams',
  headers: {'content-type': 'application/json'},
  body: {
    androidAppStreamData: {firebaseAppId: '', packageName: ''},
    createTime: '',
    displayName: '',
    iosAppStreamData: {bundleId: '', firebaseAppId: ''},
    name: '',
    type: '',
    updateTime: '',
    webStreamData: {defaultUri: '', firebaseAppId: '', measurementId: ''}
  },
  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/:parent/dataStreams');

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

req.type('json');
req.send({
  androidAppStreamData: {
    firebaseAppId: '',
    packageName: ''
  },
  createTime: '',
  displayName: '',
  iosAppStreamData: {
    bundleId: '',
    firebaseAppId: ''
  },
  name: '',
  type: '',
  updateTime: '',
  webStreamData: {
    defaultUri: '',
    firebaseAppId: '',
    measurementId: ''
  }
});

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/:parent/dataStreams',
  headers: {'content-type': 'application/json'},
  data: {
    androidAppStreamData: {firebaseAppId: '', packageName: ''},
    createTime: '',
    displayName: '',
    iosAppStreamData: {bundleId: '', firebaseAppId: ''},
    name: '',
    type: '',
    updateTime: '',
    webStreamData: {defaultUri: '', firebaseAppId: '', measurementId: ''}
  }
};

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

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

const url = '{{baseUrl}}/v1beta/:parent/dataStreams';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"androidAppStreamData":{"firebaseAppId":"","packageName":""},"createTime":"","displayName":"","iosAppStreamData":{"bundleId":"","firebaseAppId":""},"name":"","type":"","updateTime":"","webStreamData":{"defaultUri":"","firebaseAppId":"","measurementId":""}}'
};

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 = @{ @"androidAppStreamData": @{ @"firebaseAppId": @"", @"packageName": @"" },
                              @"createTime": @"",
                              @"displayName": @"",
                              @"iosAppStreamData": @{ @"bundleId": @"", @"firebaseAppId": @"" },
                              @"name": @"",
                              @"type": @"",
                              @"updateTime": @"",
                              @"webStreamData": @{ @"defaultUri": @"", @"firebaseAppId": @"", @"measurementId": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/:parent/dataStreams"]
                                                       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/:parent/dataStreams" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/v1beta/:parent/dataStreams",
  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([
    'androidAppStreamData' => [
        'firebaseAppId' => '',
        'packageName' => ''
    ],
    'createTime' => '',
    'displayName' => '',
    'iosAppStreamData' => [
        'bundleId' => '',
        'firebaseAppId' => ''
    ],
    'name' => '',
    'type' => '',
    'updateTime' => '',
    'webStreamData' => [
        'defaultUri' => '',
        'firebaseAppId' => '',
        'measurementId' => ''
    ]
  ]),
  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/:parent/dataStreams', [
  'body' => '{
  "androidAppStreamData": {
    "firebaseAppId": "",
    "packageName": ""
  },
  "createTime": "",
  "displayName": "",
  "iosAppStreamData": {
    "bundleId": "",
    "firebaseAppId": ""
  },
  "name": "",
  "type": "",
  "updateTime": "",
  "webStreamData": {
    "defaultUri": "",
    "firebaseAppId": "",
    "measurementId": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'androidAppStreamData' => [
    'firebaseAppId' => '',
    'packageName' => ''
  ],
  'createTime' => '',
  'displayName' => '',
  'iosAppStreamData' => [
    'bundleId' => '',
    'firebaseAppId' => ''
  ],
  'name' => '',
  'type' => '',
  'updateTime' => '',
  'webStreamData' => [
    'defaultUri' => '',
    'firebaseAppId' => '',
    'measurementId' => ''
  ]
]));

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

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

append(json_encode([
  'androidAppStreamData' => [
    'firebaseAppId' => '',
    'packageName' => ''
  ],
  'createTime' => '',
  'displayName' => '',
  'iosAppStreamData' => [
    'bundleId' => '',
    'firebaseAppId' => ''
  ],
  'name' => '',
  'type' => '',
  'updateTime' => '',
  'webStreamData' => [
    'defaultUri' => '',
    'firebaseAppId' => '',
    'measurementId' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/:parent/dataStreams');
$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/:parent/dataStreams' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "androidAppStreamData": {
    "firebaseAppId": "",
    "packageName": ""
  },
  "createTime": "",
  "displayName": "",
  "iosAppStreamData": {
    "bundleId": "",
    "firebaseAppId": ""
  },
  "name": "",
  "type": "",
  "updateTime": "",
  "webStreamData": {
    "defaultUri": "",
    "firebaseAppId": "",
    "measurementId": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/:parent/dataStreams' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "androidAppStreamData": {
    "firebaseAppId": "",
    "packageName": ""
  },
  "createTime": "",
  "displayName": "",
  "iosAppStreamData": {
    "bundleId": "",
    "firebaseAppId": ""
  },
  "name": "",
  "type": "",
  "updateTime": "",
  "webStreamData": {
    "defaultUri": "",
    "firebaseAppId": "",
    "measurementId": ""
  }
}'

import http.client

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

payload = "{\n  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/v1beta/:parent/dataStreams", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/dataStreams"

payload = {
    "androidAppStreamData": {
        "firebaseAppId": "",
        "packageName": ""
    },
    "createTime": "",
    "displayName": "",
    "iosAppStreamData": {
        "bundleId": "",
        "firebaseAppId": ""
    },
    "name": "",
    "type": "",
    "updateTime": "",
    "webStreamData": {
        "defaultUri": "",
        "firebaseAppId": "",
        "measurementId": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/dataStreams"

payload <- "{\n  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\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/:parent/dataStreams")

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  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\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/:parent/dataStreams') do |req|
  req.body = "{\n  \"androidAppStreamData\": {\n    \"firebaseAppId\": \"\",\n    \"packageName\": \"\"\n  },\n  \"createTime\": \"\",\n  \"displayName\": \"\",\n  \"iosAppStreamData\": {\n    \"bundleId\": \"\",\n    \"firebaseAppId\": \"\"\n  },\n  \"name\": \"\",\n  \"type\": \"\",\n  \"updateTime\": \"\",\n  \"webStreamData\": {\n    \"defaultUri\": \"\",\n    \"firebaseAppId\": \"\",\n    \"measurementId\": \"\"\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/:parent/dataStreams";

    let payload = json!({
        "androidAppStreamData": json!({
            "firebaseAppId": "",
            "packageName": ""
        }),
        "createTime": "",
        "displayName": "",
        "iosAppStreamData": json!({
            "bundleId": "",
            "firebaseAppId": ""
        }),
        "name": "",
        "type": "",
        "updateTime": "",
        "webStreamData": json!({
            "defaultUri": "",
            "firebaseAppId": "",
            "measurementId": ""
        })
    });

    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/:parent/dataStreams \
  --header 'content-type: application/json' \
  --data '{
  "androidAppStreamData": {
    "firebaseAppId": "",
    "packageName": ""
  },
  "createTime": "",
  "displayName": "",
  "iosAppStreamData": {
    "bundleId": "",
    "firebaseAppId": ""
  },
  "name": "",
  "type": "",
  "updateTime": "",
  "webStreamData": {
    "defaultUri": "",
    "firebaseAppId": "",
    "measurementId": ""
  }
}'

echo '{
  "androidAppStreamData": {
    "firebaseAppId": "",
    "packageName": ""
  },
  "createTime": "",
  "displayName": "",
  "iosAppStreamData": {
    "bundleId": "",
    "firebaseAppId": ""
  },
  "name": "",
  "type": "",
  "updateTime": "",
  "webStreamData": {
    "defaultUri": "",
    "firebaseAppId": "",
    "measurementId": ""
  }
}' |  \
  http POST {{baseUrl}}/v1beta/:parent/dataStreams \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "androidAppStreamData": {\n    "firebaseAppId": "",\n    "packageName": ""\n  },\n  "createTime": "",\n  "displayName": "",\n  "iosAppStreamData": {\n    "bundleId": "",\n    "firebaseAppId": ""\n  },\n  "name": "",\n  "type": "",\n  "updateTime": "",\n  "webStreamData": {\n    "defaultUri": "",\n    "firebaseAppId": "",\n    "measurementId": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/dataStreams

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "androidAppStreamData": [
    "firebaseAppId": "",
    "packageName": ""
  ],
  "createTime": "",
  "displayName": "",
  "iosAppStreamData": [
    "bundleId": "",
    "firebaseAppId": ""
  ],
  "name": "",
  "type": "",
  "updateTime": "",
  "webStreamData": [
    "defaultUri": "",
    "firebaseAppId": "",
    "measurementId": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/dataStreams")! 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 analyticsadmin.properties.dataStreams.list

{{baseUrl}}/v1beta/:parent/dataStreams

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/:parent/dataStreams")

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/dataStreams"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/dataStreams"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta/:parent/dataStreams'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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/:parent/dataStreams');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1beta/:parent/dataStreams")

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/dataStreams"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/dataStreams"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/:parent/dataStreams")

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

puts response.status
puts response.body

use reqwest;

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

    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/:parent/dataStreams

http GET {{baseUrl}}/v1beta/:parent/dataStreams

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/dataStreams

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/dataStreams")! 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 analyticsadmin.properties.dataStreams.measurementProtocolSecrets.create

{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets

QUERY PARAMS

parent

BODY json

{
  "displayName": "",
  "name": "",
  "secretValue": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"displayName\": \"\",\n  \"name\": \"\",\n  \"secretValue\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets" {:content-type :json
                                                                                      :form-params {:displayName ""
                                                                                                    :name ""
                                                                                                    :secretValue ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"secretValue\": \"\"\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/:parent/measurementProtocolSecrets"),
    Content = new StringContent("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"secretValue\": \"\"\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/:parent/measurementProtocolSecrets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"secretValue\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets"

	payload := strings.NewReader("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"secretValue\": \"\"\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/:parent/measurementProtocolSecrets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "displayName": "",
  "name": "",
  "secretValue": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"secretValue\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets")
  .header("content-type", "application/json")
  .body("{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"secretValue\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  displayName: '',
  name: '',
  secretValue: ''
});

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/:parent/measurementProtocolSecrets');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets',
  headers: {'content-type': 'application/json'},
  data: {displayName: '', name: '', secretValue: ''}
};

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

const url = '{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"displayName":"","name":"","secretValue":""}'
};

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/:parent/measurementProtocolSecrets',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "displayName": "",\n  "name": "",\n  "secretValue": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  displayName: '',
  name: '',
  secretValue: ''
});

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/:parent/measurementProtocolSecrets',
  headers: {'content-type': 'application/json'},
  data: {displayName: '', name: '', secretValue: ''}
};

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

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

const url = '{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"displayName":"","name":"","secretValue":""}'
};

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 = @{ @"displayName": @"",
                              @"name": @"",
                              @"secretValue": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'displayName' => '',
  'name' => '',
  'secretValue' => ''
]));

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

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

append(json_encode([
  'displayName' => '',
  'name' => '',
  'secretValue' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets');
$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/:parent/measurementProtocolSecrets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "displayName": "",
  "name": "",
  "secretValue": ""
}'

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

import http.client

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

payload = "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"secretValue\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta/:parent/measurementProtocolSecrets", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets"

payload = {
    "displayName": "",
    "name": "",
    "secretValue": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets"

payload <- "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"secretValue\": \"\"\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/:parent/measurementProtocolSecrets")

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  \"displayName\": \"\",\n  \"name\": \"\",\n  \"secretValue\": \"\"\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/:parent/measurementProtocolSecrets') do |req|
  req.body = "{\n  \"displayName\": \"\",\n  \"name\": \"\",\n  \"secretValue\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "displayName": "",
        "name": "",
        "secretValue": ""
    });

    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/:parent/measurementProtocolSecrets \
  --header 'content-type: application/json' \
  --data '{
  "displayName": "",
  "name": "",
  "secretValue": ""
}'

echo '{
  "displayName": "",
  "name": "",
  "secretValue": ""
}' |  \
  http POST {{baseUrl}}/v1beta/:parent/measurementProtocolSecrets \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "displayName": "",\n  "name": "",\n  "secretValue": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/measurementProtocolSecrets

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets")! 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 analyticsadmin.properties.dataStreams.measurementProtocolSecrets.get

{{baseUrl}}/v1beta/:name

QUERY PARAMS

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/:name")

require "http/client"

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

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

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

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

package main

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

func main() {

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

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

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

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

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

}

GET /baseUrl/v1beta/:name HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/v1beta/:name');

xhr.send(data);

import axios from 'axios';

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

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

const url = '{{baseUrl}}/v1beta/:name';
const options = {method: 'GET'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

const url = '{{baseUrl}}/v1beta/:name';
const options = {method: 'GET'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1beta/:name" in

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

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

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/v1beta/:name');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/v1beta/:name') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/v1beta/:name

http GET {{baseUrl}}/v1beta/:name

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

import Foundation

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

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

dataTask.resume()

GET analyticsadmin.properties.dataStreams.measurementProtocolSecrets.list

{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets")

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets'
};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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/:parent/measurementProtocolSecrets');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1beta/:parent/measurementProtocolSecrets")

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets")

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

puts response.status
puts response.body

use reqwest;

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

    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/:parent/measurementProtocolSecrets

http GET {{baseUrl}}/v1beta/:parent/measurementProtocolSecrets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/measurementProtocolSecrets

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/measurementProtocolSecrets")! 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 analyticsadmin.properties.firebaseLinks.create

{{baseUrl}}/v1beta/:parent/firebaseLinks

QUERY PARAMS

parent

BODY json

{
  "createTime": "",
  "name": "",
  "project": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"createTime\": \"\",\n  \"name\": \"\",\n  \"project\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/:parent/firebaseLinks" {:content-type :json
                                                                         :form-params {:createTime ""
                                                                                       :name ""
                                                                                       :project ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/firebaseLinks"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"createTime\": \"\",\n  \"name\": \"\",\n  \"project\": \"\"\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/:parent/firebaseLinks"),
    Content = new StringContent("{\n  \"createTime\": \"\",\n  \"name\": \"\",\n  \"project\": \"\"\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/:parent/firebaseLinks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"createTime\": \"\",\n  \"name\": \"\",\n  \"project\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/firebaseLinks"

	payload := strings.NewReader("{\n  \"createTime\": \"\",\n  \"name\": \"\",\n  \"project\": \"\"\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/:parent/firebaseLinks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "createTime": "",
  "name": "",
  "project": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/:parent/firebaseLinks")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"createTime\": \"\",\n  \"name\": \"\",\n  \"project\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/:parent/firebaseLinks")
  .header("content-type", "application/json")
  .body("{\n  \"createTime\": \"\",\n  \"name\": \"\",\n  \"project\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  createTime: '',
  name: '',
  project: ''
});

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/:parent/firebaseLinks');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/firebaseLinks',
  headers: {'content-type': 'application/json'},
  data: {createTime: '', name: '', project: ''}
};

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

const url = '{{baseUrl}}/v1beta/:parent/firebaseLinks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"createTime":"","name":"","project":""}'
};

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/:parent/firebaseLinks',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "createTime": "",\n  "name": "",\n  "project": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  createTime: '',
  name: '',
  project: ''
});

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/:parent/firebaseLinks',
  headers: {'content-type': 'application/json'},
  data: {createTime: '', name: '', project: ''}
};

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

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

const url = '{{baseUrl}}/v1beta/:parent/firebaseLinks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"createTime":"","name":"","project":""}'
};

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 = @{ @"createTime": @"",
                              @"name": @"",
                              @"project": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'createTime' => '',
  'name' => '',
  'project' => ''
]));

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

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

append(json_encode([
  'createTime' => '',
  'name' => '',
  'project' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/:parent/firebaseLinks');
$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/:parent/firebaseLinks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "createTime": "",
  "name": "",
  "project": ""
}'

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

import http.client

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

payload = "{\n  \"createTime\": \"\",\n  \"name\": \"\",\n  \"project\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta/:parent/firebaseLinks", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/firebaseLinks"

payload = {
    "createTime": "",
    "name": "",
    "project": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/firebaseLinks"

payload <- "{\n  \"createTime\": \"\",\n  \"name\": \"\",\n  \"project\": \"\"\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/:parent/firebaseLinks")

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  \"createTime\": \"\",\n  \"name\": \"\",\n  \"project\": \"\"\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/:parent/firebaseLinks') do |req|
  req.body = "{\n  \"createTime\": \"\",\n  \"name\": \"\",\n  \"project\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "createTime": "",
        "name": "",
        "project": ""
    });

    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/:parent/firebaseLinks \
  --header 'content-type: application/json' \
  --data '{
  "createTime": "",
  "name": "",
  "project": ""
}'

echo '{
  "createTime": "",
  "name": "",
  "project": ""
}' |  \
  http POST {{baseUrl}}/v1beta/:parent/firebaseLinks \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "createTime": "",\n  "name": "",\n  "project": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/firebaseLinks

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/firebaseLinks")! 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 analyticsadmin.properties.firebaseLinks.list

{{baseUrl}}/v1beta/:parent/firebaseLinks

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/:parent/firebaseLinks")

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/firebaseLinks"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/firebaseLinks"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta/:parent/firebaseLinks'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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/:parent/firebaseLinks');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1beta/:parent/firebaseLinks")

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/firebaseLinks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/firebaseLinks"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/:parent/firebaseLinks")

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

puts response.status
puts response.body

use reqwest;

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

    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/:parent/firebaseLinks

http GET {{baseUrl}}/v1beta/:parent/firebaseLinks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/firebaseLinks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/firebaseLinks")! 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 analyticsadmin.properties.googleAdsLinks.create

{{baseUrl}}/v1beta/:parent/googleAdsLinks

QUERY PARAMS

parent

BODY json

{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v1beta/:parent/googleAdsLinks" {:content-type :json
                                                                          :form-params {:adsPersonalizationEnabled false
                                                                                        :canManageClients false
                                                                                        :createTime ""
                                                                                        :creatorEmailAddress ""
                                                                                        :customerId ""
                                                                                        :name ""
                                                                                        :updateTime ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/googleAdsLinks"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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/:parent/googleAdsLinks"),
    Content = new StringContent("{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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/:parent/googleAdsLinks");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/googleAdsLinks"

	payload := strings.NewReader("{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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/:parent/googleAdsLinks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 172

{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/:parent/googleAdsLinks")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/:parent/googleAdsLinks"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/:parent/googleAdsLinks")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/:parent/googleAdsLinks")
  .header("content-type", "application/json")
  .body("{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  adsPersonalizationEnabled: false,
  canManageClients: false,
  createTime: '',
  creatorEmailAddress: '',
  customerId: '',
  name: '',
  updateTime: ''
});

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/:parent/googleAdsLinks');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/googleAdsLinks',
  headers: {'content-type': 'application/json'},
  data: {
    adsPersonalizationEnabled: false,
    canManageClients: false,
    createTime: '',
    creatorEmailAddress: '',
    customerId: '',
    name: '',
    updateTime: ''
  }
};

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

const url = '{{baseUrl}}/v1beta/:parent/googleAdsLinks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"adsPersonalizationEnabled":false,"canManageClients":false,"createTime":"","creatorEmailAddress":"","customerId":"","name":"","updateTime":""}'
};

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/:parent/googleAdsLinks',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "adsPersonalizationEnabled": false,\n  "canManageClients": false,\n  "createTime": "",\n  "creatorEmailAddress": "",\n  "customerId": "",\n  "name": "",\n  "updateTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/:parent/googleAdsLinks")
  .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/:parent/googleAdsLinks',
  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({
  adsPersonalizationEnabled: false,
  canManageClients: false,
  createTime: '',
  creatorEmailAddress: '',
  customerId: '',
  name: '',
  updateTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:parent/googleAdsLinks',
  headers: {'content-type': 'application/json'},
  body: {
    adsPersonalizationEnabled: false,
    canManageClients: false,
    createTime: '',
    creatorEmailAddress: '',
    customerId: '',
    name: '',
    updateTime: ''
  },
  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/:parent/googleAdsLinks');

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

req.type('json');
req.send({
  adsPersonalizationEnabled: false,
  canManageClients: false,
  createTime: '',
  creatorEmailAddress: '',
  customerId: '',
  name: '',
  updateTime: ''
});

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/:parent/googleAdsLinks',
  headers: {'content-type': 'application/json'},
  data: {
    adsPersonalizationEnabled: false,
    canManageClients: false,
    createTime: '',
    creatorEmailAddress: '',
    customerId: '',
    name: '',
    updateTime: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta/:parent/googleAdsLinks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"adsPersonalizationEnabled":false,"canManageClients":false,"createTime":"","creatorEmailAddress":"","customerId":"","name":"","updateTime":""}'
};

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 = @{ @"adsPersonalizationEnabled": @NO,
                              @"canManageClients": @NO,
                              @"createTime": @"",
                              @"creatorEmailAddress": @"",
                              @"customerId": @"",
                              @"name": @"",
                              @"updateTime": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/:parent/googleAdsLinks"]
                                                       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/:parent/googleAdsLinks" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/:parent/googleAdsLinks",
  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([
    'adsPersonalizationEnabled' => null,
    'canManageClients' => null,
    'createTime' => '',
    'creatorEmailAddress' => '',
    'customerId' => '',
    'name' => '',
    'updateTime' => ''
  ]),
  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/:parent/googleAdsLinks', [
  'body' => '{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'adsPersonalizationEnabled' => null,
  'canManageClients' => null,
  'createTime' => '',
  'creatorEmailAddress' => '',
  'customerId' => '',
  'name' => '',
  'updateTime' => ''
]));

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

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

append(json_encode([
  'adsPersonalizationEnabled' => null,
  'canManageClients' => null,
  'createTime' => '',
  'creatorEmailAddress' => '',
  'customerId' => '',
  'name' => '',
  'updateTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/:parent/googleAdsLinks');
$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/:parent/googleAdsLinks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/:parent/googleAdsLinks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}'

import http.client

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

payload = "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v1beta/:parent/googleAdsLinks", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/googleAdsLinks"

payload = {
    "adsPersonalizationEnabled": False,
    "canManageClients": False,
    "createTime": "",
    "creatorEmailAddress": "",
    "customerId": "",
    "name": "",
    "updateTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/googleAdsLinks"

payload <- "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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/:parent/googleAdsLinks")

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  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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/:parent/googleAdsLinks') do |req|
  req.body = "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "adsPersonalizationEnabled": false,
        "canManageClients": false,
        "createTime": "",
        "creatorEmailAddress": "",
        "customerId": "",
        "name": "",
        "updateTime": ""
    });

    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/:parent/googleAdsLinks \
  --header 'content-type: application/json' \
  --data '{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}'

echo '{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}' |  \
  http POST {{baseUrl}}/v1beta/:parent/googleAdsLinks \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "adsPersonalizationEnabled": false,\n  "canManageClients": false,\n  "createTime": "",\n  "creatorEmailAddress": "",\n  "customerId": "",\n  "name": "",\n  "updateTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/googleAdsLinks

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/googleAdsLinks")! 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 analyticsadmin.properties.googleAdsLinks.delete

{{baseUrl}}/v1beta/:name

QUERY PARAMS

name

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/:name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v1beta/:name")

require "http/client"

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

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

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

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

package main

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

func main() {

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

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

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

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

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

}

DELETE /baseUrl/v1beta/:name HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/:name")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v1beta/:name")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/v1beta/:name');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/v1beta/:name'};

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

const url = '{{baseUrl}}/v1beta/:name';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1beta/:name',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/:name")
  .delete(null)
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/v1beta/:name'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1beta/:name');

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

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

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

const options = {method: 'DELETE', url: '{{baseUrl}}/v1beta/:name'};

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

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

const url = '{{baseUrl}}/v1beta/:name';
const options = {method: 'DELETE'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1beta/:name" in

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

 "{{baseUrl}}/v1beta/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/v1beta/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/:name');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/:name' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/:name' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/v1beta/:name")

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/v1beta/:name') do |req|
end

puts response.status
puts response.body

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

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/v1beta/:name

http DELETE {{baseUrl}}/v1beta/:name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v1beta/:name

import Foundation

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

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

dataTask.resume()

GET analyticsadmin.properties.googleAdsLinks.list

{{baseUrl}}/v1beta/:parent/googleAdsLinks

QUERY PARAMS

parent

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/:parent/googleAdsLinks")

require "http/client"

url = "{{baseUrl}}/v1beta/:parent/googleAdsLinks"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v1beta/:parent/googleAdsLinks"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v1beta/:parent/googleAdsLinks'
};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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/:parent/googleAdsLinks');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/v1beta/:parent/googleAdsLinks")

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

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

import requests

url = "{{baseUrl}}/v1beta/:parent/googleAdsLinks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:parent/googleAdsLinks"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/:parent/googleAdsLinks")

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

puts response.status
puts response.body

use reqwest;

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

    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/:parent/googleAdsLinks

http GET {{baseUrl}}/v1beta/:parent/googleAdsLinks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/:parent/googleAdsLinks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:parent/googleAdsLinks")! 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 analyticsadmin.properties.googleAdsLinks.patch

{{baseUrl}}/v1beta/:name

QUERY PARAMS

name

BODY json

{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v1beta/:name" {:content-type :json
                                                          :form-params {:adsPersonalizationEnabled false
                                                                        :canManageClients false
                                                                        :createTime ""
                                                                        :creatorEmailAddress ""
                                                                        :customerId ""
                                                                        :name ""
                                                                        :updateTime ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/:name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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/:name"),
    Content = new StringContent("{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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/:name");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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/:name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 172

{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v1beta/:name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/:name"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/:name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v1beta/:name")
  .header("content-type", "application/json")
  .body("{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  adsPersonalizationEnabled: false,
  canManageClients: false,
  createTime: '',
  creatorEmailAddress: '',
  customerId: '',
  name: '',
  updateTime: ''
});

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/:name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/:name',
  headers: {'content-type': 'application/json'},
  data: {
    adsPersonalizationEnabled: false,
    canManageClients: false,
    createTime: '',
    creatorEmailAddress: '',
    customerId: '',
    name: '',
    updateTime: ''
  }
};

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

const url = '{{baseUrl}}/v1beta/:name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"adsPersonalizationEnabled":false,"canManageClients":false,"createTime":"","creatorEmailAddress":"","customerId":"","name":"","updateTime":""}'
};

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/:name',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "adsPersonalizationEnabled": false,\n  "canManageClients": false,\n  "createTime": "",\n  "creatorEmailAddress": "",\n  "customerId": "",\n  "name": "",\n  "updateTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/:name")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  adsPersonalizationEnabled: false,
  canManageClients: false,
  createTime: '',
  creatorEmailAddress: '',
  customerId: '',
  name: '',
  updateTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v1beta/:name',
  headers: {'content-type': 'application/json'},
  body: {
    adsPersonalizationEnabled: false,
    canManageClients: false,
    createTime: '',
    creatorEmailAddress: '',
    customerId: '',
    name: '',
    updateTime: ''
  },
  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/:name');

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

req.type('json');
req.send({
  adsPersonalizationEnabled: false,
  canManageClients: false,
  createTime: '',
  creatorEmailAddress: '',
  customerId: '',
  name: '',
  updateTime: ''
});

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/:name',
  headers: {'content-type': 'application/json'},
  data: {
    adsPersonalizationEnabled: false,
    canManageClients: false,
    createTime: '',
    creatorEmailAddress: '',
    customerId: '',
    name: '',
    updateTime: ''
  }
};

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

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

const url = '{{baseUrl}}/v1beta/:name';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"adsPersonalizationEnabled":false,"canManageClients":false,"createTime":"","creatorEmailAddress":"","customerId":"","name":"","updateTime":""}'
};

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 = @{ @"adsPersonalizationEnabled": @NO,
                              @"canManageClients": @NO,
                              @"createTime": @"",
                              @"creatorEmailAddress": @"",
                              @"customerId": @"",
                              @"name": @"",
                              @"updateTime": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1beta/:name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}" in

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

 "{{baseUrl}}/v1beta/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'adsPersonalizationEnabled' => null,
    'canManageClients' => null,
    'createTime' => '',
    'creatorEmailAddress' => '',
    'customerId' => '',
    'name' => '',
    'updateTime' => ''
  ]),
  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/:name', [
  'body' => '{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'adsPersonalizationEnabled' => null,
  'canManageClients' => null,
  'createTime' => '',
  'creatorEmailAddress' => '',
  'customerId' => '',
  'name' => '',
  'updateTime' => ''
]));

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

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

append(json_encode([
  'adsPersonalizationEnabled' => null,
  'canManageClients' => null,
  'createTime' => '',
  'creatorEmailAddress' => '',
  'customerId' => '',
  'name' => '',
  'updateTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/:name');
$request->setRequestMethod('PATCH');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/:name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/:name' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}'

import http.client

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

payload = "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\n}"

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

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

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

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

import requests

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

payload = {
    "adsPersonalizationEnabled": False,
    "canManageClients": False,
    "createTime": "",
    "creatorEmailAddress": "",
    "customerId": "",
    "name": "",
    "updateTime": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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/:name")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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/:name') do |req|
  req.body = "{\n  \"adsPersonalizationEnabled\": false,\n  \"canManageClients\": false,\n  \"createTime\": \"\",\n  \"creatorEmailAddress\": \"\",\n  \"customerId\": \"\",\n  \"name\": \"\",\n  \"updateTime\": \"\"\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/:name";

    let payload = json!({
        "adsPersonalizationEnabled": false,
        "canManageClients": false,
        "createTime": "",
        "creatorEmailAddress": "",
        "customerId": "",
        "name": "",
        "updateTime": ""
    });

    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/:name \
  --header 'content-type: application/json' \
  --data '{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}'

echo '{
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
}' |  \
  http PATCH {{baseUrl}}/v1beta/:name \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "adsPersonalizationEnabled": false,\n  "canManageClients": false,\n  "createTime": "",\n  "creatorEmailAddress": "",\n  "customerId": "",\n  "name": "",\n  "updateTime": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/:name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "adsPersonalizationEnabled": false,
  "canManageClients": false,
  "createTime": "",
  "creatorEmailAddress": "",
  "customerId": "",
  "name": "",
  "updateTime": ""
] as [String : Any]

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

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

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

dataTask.resume()

GET analyticsadmin.properties.list

{{baseUrl}}/v1beta/properties

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/properties");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v1beta/properties")

require "http/client"

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

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1beta/properties'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/properties")
  .get()
  .build()

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

const http = require('https');

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

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/properties');

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/properties'};

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

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

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

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

 "{{baseUrl}}/v1beta/properties",
  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/properties');

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/properties');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1beta/properties' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/properties' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/v1beta/properties")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/properties")

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/properties') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/properties";

    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/properties

http GET {{baseUrl}}/v1beta/properties

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1beta/properties

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/properties")! 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 analyticsadmin.properties.runAccessReport

{{baseUrl}}/v1beta/:entity:runAccessReport

QUERY PARAMS

entity

BODY json

{
  "dateRanges": [
    {
      "endDate": "",
      "startDate": ""
    }
  ],
  "dimensionFilter": {
    "accessFilter": {
      "betweenFilter": {
        "fromValue": {
          "doubleValue": "",
          "int64Value": ""
        },
        "toValue": {}
      },
      "fieldName": "",
      "inListFilter": {
        "caseSensitive": false,
        "values": []
      },
      "numericFilter": {
        "operation": "",
        "value": {}
      },
      "stringFilter": {
        "caseSensitive": false,
        "matchType": "",
        "value": ""
      }
    },
    "andGroup": {
      "expressions": []
    },
    "notExpression": "",
    "orGroup": {}
  },
  "dimensions": [
    {
      "dimensionName": ""
    }
  ],
  "limit": "",
  "metricFilter": {},
  "metrics": [
    {
      "metricName": ""
    }
  ],
  "offset": "",
  "orderBys": [
    {
      "desc": false,
      "dimension": {
        "dimensionName": "",
        "orderType": ""
      },
      "metric": {
        "metricName": ""
      }
    }
  ],
  "returnEntityQuota": false,
  "timeZone": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1beta/:entity:runAccessReport");

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  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1beta/:entity:runAccessReport" {:content-type :json
                                                                           :form-params {:dateRanges [{:endDate ""
                                                                                                       :startDate ""}]
                                                                                         :dimensionFilter {:accessFilter {:betweenFilter {:fromValue {:doubleValue ""
                                                                                                                                                      :int64Value ""}
                                                                                                                                          :toValue {}}
                                                                                                                          :fieldName ""
                                                                                                                          :inListFilter {:caseSensitive false
                                                                                                                                         :values []}
                                                                                                                          :numericFilter {:operation ""
                                                                                                                                          :value {}}
                                                                                                                          :stringFilter {:caseSensitive false
                                                                                                                                         :matchType ""
                                                                                                                                         :value ""}}
                                                                                                           :andGroup {:expressions []}
                                                                                                           :notExpression ""
                                                                                                           :orGroup {}}
                                                                                         :dimensions [{:dimensionName ""}]
                                                                                         :limit ""
                                                                                         :metricFilter {}
                                                                                         :metrics [{:metricName ""}]
                                                                                         :offset ""
                                                                                         :orderBys [{:desc false
                                                                                                     :dimension {:dimensionName ""
                                                                                                                 :orderType ""}
                                                                                                     :metric {:metricName ""}}]
                                                                                         :returnEntityQuota false
                                                                                         :timeZone ""}})

require "http/client"

url = "{{baseUrl}}/v1beta/:entity:runAccessReport"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1beta/:entity:runAccessReport"),
    Content = new StringContent("{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1beta/:entity:runAccessReport");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1beta/:entity:runAccessReport"

	payload := strings.NewReader("{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1beta/:entity:runAccessReport HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1077

{
  "dateRanges": [
    {
      "endDate": "",
      "startDate": ""
    }
  ],
  "dimensionFilter": {
    "accessFilter": {
      "betweenFilter": {
        "fromValue": {
          "doubleValue": "",
          "int64Value": ""
        },
        "toValue": {}
      },
      "fieldName": "",
      "inListFilter": {
        "caseSensitive": false,
        "values": []
      },
      "numericFilter": {
        "operation": "",
        "value": {}
      },
      "stringFilter": {
        "caseSensitive": false,
        "matchType": "",
        "value": ""
      }
    },
    "andGroup": {
      "expressions": []
    },
    "notExpression": "",
    "orGroup": {}
  },
  "dimensions": [
    {
      "dimensionName": ""
    }
  ],
  "limit": "",
  "metricFilter": {},
  "metrics": [
    {
      "metricName": ""
    }
  ],
  "offset": "",
  "orderBys": [
    {
      "desc": false,
      "dimension": {
        "dimensionName": "",
        "orderType": ""
      },
      "metric": {
        "metricName": ""
      }
    }
  ],
  "returnEntityQuota": false,
  "timeZone": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1beta/:entity:runAccessReport")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1beta/:entity:runAccessReport"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1beta/:entity:runAccessReport")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1beta/:entity:runAccessReport")
  .header("content-type", "application/json")
  .body("{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  dateRanges: [
    {
      endDate: '',
      startDate: ''
    }
  ],
  dimensionFilter: {
    accessFilter: {
      betweenFilter: {
        fromValue: {
          doubleValue: '',
          int64Value: ''
        },
        toValue: {}
      },
      fieldName: '',
      inListFilter: {
        caseSensitive: false,
        values: []
      },
      numericFilter: {
        operation: '',
        value: {}
      },
      stringFilter: {
        caseSensitive: false,
        matchType: '',
        value: ''
      }
    },
    andGroup: {
      expressions: []
    },
    notExpression: '',
    orGroup: {}
  },
  dimensions: [
    {
      dimensionName: ''
    }
  ],
  limit: '',
  metricFilter: {},
  metrics: [
    {
      metricName: ''
    }
  ],
  offset: '',
  orderBys: [
    {
      desc: false,
      dimension: {
        dimensionName: '',
        orderType: ''
      },
      metric: {
        metricName: ''
      }
    }
  ],
  returnEntityQuota: false,
  timeZone: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1beta/:entity:runAccessReport');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:entity:runAccessReport',
  headers: {'content-type': 'application/json'},
  data: {
    dateRanges: [{endDate: '', startDate: ''}],
    dimensionFilter: {
      accessFilter: {
        betweenFilter: {fromValue: {doubleValue: '', int64Value: ''}, toValue: {}},
        fieldName: '',
        inListFilter: {caseSensitive: false, values: []},
        numericFilter: {operation: '', value: {}},
        stringFilter: {caseSensitive: false, matchType: '', value: ''}
      },
      andGroup: {expressions: []},
      notExpression: '',
      orGroup: {}
    },
    dimensions: [{dimensionName: ''}],
    limit: '',
    metricFilter: {},
    metrics: [{metricName: ''}],
    offset: '',
    orderBys: [
      {
        desc: false,
        dimension: {dimensionName: '', orderType: ''},
        metric: {metricName: ''}
      }
    ],
    returnEntityQuota: false,
    timeZone: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1beta/:entity:runAccessReport';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"dateRanges":[{"endDate":"","startDate":""}],"dimensionFilter":{"accessFilter":{"betweenFilter":{"fromValue":{"doubleValue":"","int64Value":""},"toValue":{}},"fieldName":"","inListFilter":{"caseSensitive":false,"values":[]},"numericFilter":{"operation":"","value":{}},"stringFilter":{"caseSensitive":false,"matchType":"","value":""}},"andGroup":{"expressions":[]},"notExpression":"","orGroup":{}},"dimensions":[{"dimensionName":""}],"limit":"","metricFilter":{},"metrics":[{"metricName":""}],"offset":"","orderBys":[{"desc":false,"dimension":{"dimensionName":"","orderType":""},"metric":{"metricName":""}}],"returnEntityQuota":false,"timeZone":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1beta/:entity:runAccessReport',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "dateRanges": [\n    {\n      "endDate": "",\n      "startDate": ""\n    }\n  ],\n  "dimensionFilter": {\n    "accessFilter": {\n      "betweenFilter": {\n        "fromValue": {\n          "doubleValue": "",\n          "int64Value": ""\n        },\n        "toValue": {}\n      },\n      "fieldName": "",\n      "inListFilter": {\n        "caseSensitive": false,\n        "values": []\n      },\n      "numericFilter": {\n        "operation": "",\n        "value": {}\n      },\n      "stringFilter": {\n        "caseSensitive": false,\n        "matchType": "",\n        "value": ""\n      }\n    },\n    "andGroup": {\n      "expressions": []\n    },\n    "notExpression": "",\n    "orGroup": {}\n  },\n  "dimensions": [\n    {\n      "dimensionName": ""\n    }\n  ],\n  "limit": "",\n  "metricFilter": {},\n  "metrics": [\n    {\n      "metricName": ""\n    }\n  ],\n  "offset": "",\n  "orderBys": [\n    {\n      "desc": false,\n      "dimension": {\n        "dimensionName": "",\n        "orderType": ""\n      },\n      "metric": {\n        "metricName": ""\n      }\n    }\n  ],\n  "returnEntityQuota": false,\n  "timeZone": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1beta/:entity:runAccessReport")
  .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/:entity:runAccessReport',
  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({
  dateRanges: [{endDate: '', startDate: ''}],
  dimensionFilter: {
    accessFilter: {
      betweenFilter: {fromValue: {doubleValue: '', int64Value: ''}, toValue: {}},
      fieldName: '',
      inListFilter: {caseSensitive: false, values: []},
      numericFilter: {operation: '', value: {}},
      stringFilter: {caseSensitive: false, matchType: '', value: ''}
    },
    andGroup: {expressions: []},
    notExpression: '',
    orGroup: {}
  },
  dimensions: [{dimensionName: ''}],
  limit: '',
  metricFilter: {},
  metrics: [{metricName: ''}],
  offset: '',
  orderBys: [
    {
      desc: false,
      dimension: {dimensionName: '', orderType: ''},
      metric: {metricName: ''}
    }
  ],
  returnEntityQuota: false,
  timeZone: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:entity:runAccessReport',
  headers: {'content-type': 'application/json'},
  body: {
    dateRanges: [{endDate: '', startDate: ''}],
    dimensionFilter: {
      accessFilter: {
        betweenFilter: {fromValue: {doubleValue: '', int64Value: ''}, toValue: {}},
        fieldName: '',
        inListFilter: {caseSensitive: false, values: []},
        numericFilter: {operation: '', value: {}},
        stringFilter: {caseSensitive: false, matchType: '', value: ''}
      },
      andGroup: {expressions: []},
      notExpression: '',
      orGroup: {}
    },
    dimensions: [{dimensionName: ''}],
    limit: '',
    metricFilter: {},
    metrics: [{metricName: ''}],
    offset: '',
    orderBys: [
      {
        desc: false,
        dimension: {dimensionName: '', orderType: ''},
        metric: {metricName: ''}
      }
    ],
    returnEntityQuota: false,
    timeZone: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1beta/:entity:runAccessReport');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  dateRanges: [
    {
      endDate: '',
      startDate: ''
    }
  ],
  dimensionFilter: {
    accessFilter: {
      betweenFilter: {
        fromValue: {
          doubleValue: '',
          int64Value: ''
        },
        toValue: {}
      },
      fieldName: '',
      inListFilter: {
        caseSensitive: false,
        values: []
      },
      numericFilter: {
        operation: '',
        value: {}
      },
      stringFilter: {
        caseSensitive: false,
        matchType: '',
        value: ''
      }
    },
    andGroup: {
      expressions: []
    },
    notExpression: '',
    orGroup: {}
  },
  dimensions: [
    {
      dimensionName: ''
    }
  ],
  limit: '',
  metricFilter: {},
  metrics: [
    {
      metricName: ''
    }
  ],
  offset: '',
  orderBys: [
    {
      desc: false,
      dimension: {
        dimensionName: '',
        orderType: ''
      },
      metric: {
        metricName: ''
      }
    }
  ],
  returnEntityQuota: false,
  timeZone: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1beta/:entity:runAccessReport',
  headers: {'content-type': 'application/json'},
  data: {
    dateRanges: [{endDate: '', startDate: ''}],
    dimensionFilter: {
      accessFilter: {
        betweenFilter: {fromValue: {doubleValue: '', int64Value: ''}, toValue: {}},
        fieldName: '',
        inListFilter: {caseSensitive: false, values: []},
        numericFilter: {operation: '', value: {}},
        stringFilter: {caseSensitive: false, matchType: '', value: ''}
      },
      andGroup: {expressions: []},
      notExpression: '',
      orGroup: {}
    },
    dimensions: [{dimensionName: ''}],
    limit: '',
    metricFilter: {},
    metrics: [{metricName: ''}],
    offset: '',
    orderBys: [
      {
        desc: false,
        dimension: {dimensionName: '', orderType: ''},
        metric: {metricName: ''}
      }
    ],
    returnEntityQuota: false,
    timeZone: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1beta/:entity:runAccessReport';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"dateRanges":[{"endDate":"","startDate":""}],"dimensionFilter":{"accessFilter":{"betweenFilter":{"fromValue":{"doubleValue":"","int64Value":""},"toValue":{}},"fieldName":"","inListFilter":{"caseSensitive":false,"values":[]},"numericFilter":{"operation":"","value":{}},"stringFilter":{"caseSensitive":false,"matchType":"","value":""}},"andGroup":{"expressions":[]},"notExpression":"","orGroup":{}},"dimensions":[{"dimensionName":""}],"limit":"","metricFilter":{},"metrics":[{"metricName":""}],"offset":"","orderBys":[{"desc":false,"dimension":{"dimensionName":"","orderType":""},"metric":{"metricName":""}}],"returnEntityQuota":false,"timeZone":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"dateRanges": @[ @{ @"endDate": @"", @"startDate": @"" } ],
                              @"dimensionFilter": @{ @"accessFilter": @{ @"betweenFilter": @{ @"fromValue": @{ @"doubleValue": @"", @"int64Value": @"" }, @"toValue": @{  } }, @"fieldName": @"", @"inListFilter": @{ @"caseSensitive": @NO, @"values": @[  ] }, @"numericFilter": @{ @"operation": @"", @"value": @{  } }, @"stringFilter": @{ @"caseSensitive": @NO, @"matchType": @"", @"value": @"" } }, @"andGroup": @{ @"expressions": @[  ] }, @"notExpression": @"", @"orGroup": @{  } },
                              @"dimensions": @[ @{ @"dimensionName": @"" } ],
                              @"limit": @"",
                              @"metricFilter": @{  },
                              @"metrics": @[ @{ @"metricName": @"" } ],
                              @"offset": @"",
                              @"orderBys": @[ @{ @"desc": @NO, @"dimension": @{ @"dimensionName": @"", @"orderType": @"" }, @"metric": @{ @"metricName": @"" } } ],
                              @"returnEntityQuota": @NO,
                              @"timeZone": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1beta/:entity:runAccessReport"]
                                                       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/:entity:runAccessReport" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1beta/:entity:runAccessReport",
  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([
    'dateRanges' => [
        [
                'endDate' => '',
                'startDate' => ''
        ]
    ],
    'dimensionFilter' => [
        'accessFilter' => [
                'betweenFilter' => [
                                'fromValue' => [
                                                                'doubleValue' => '',
                                                                'int64Value' => ''
                                ],
                                'toValue' => [
                                                                
                                ]
                ],
                'fieldName' => '',
                'inListFilter' => [
                                'caseSensitive' => null,
                                'values' => [
                                                                
                                ]
                ],
                'numericFilter' => [
                                'operation' => '',
                                'value' => [
                                                                
                                ]
                ],
                'stringFilter' => [
                                'caseSensitive' => null,
                                'matchType' => '',
                                'value' => ''
                ]
        ],
        'andGroup' => [
                'expressions' => [
                                
                ]
        ],
        'notExpression' => '',
        'orGroup' => [
                
        ]
    ],
    'dimensions' => [
        [
                'dimensionName' => ''
        ]
    ],
    'limit' => '',
    'metricFilter' => [
        
    ],
    'metrics' => [
        [
                'metricName' => ''
        ]
    ],
    'offset' => '',
    'orderBys' => [
        [
                'desc' => null,
                'dimension' => [
                                'dimensionName' => '',
                                'orderType' => ''
                ],
                'metric' => [
                                'metricName' => ''
                ]
        ]
    ],
    'returnEntityQuota' => null,
    'timeZone' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1beta/:entity:runAccessReport', [
  'body' => '{
  "dateRanges": [
    {
      "endDate": "",
      "startDate": ""
    }
  ],
  "dimensionFilter": {
    "accessFilter": {
      "betweenFilter": {
        "fromValue": {
          "doubleValue": "",
          "int64Value": ""
        },
        "toValue": {}
      },
      "fieldName": "",
      "inListFilter": {
        "caseSensitive": false,
        "values": []
      },
      "numericFilter": {
        "operation": "",
        "value": {}
      },
      "stringFilter": {
        "caseSensitive": false,
        "matchType": "",
        "value": ""
      }
    },
    "andGroup": {
      "expressions": []
    },
    "notExpression": "",
    "orGroup": {}
  },
  "dimensions": [
    {
      "dimensionName": ""
    }
  ],
  "limit": "",
  "metricFilter": {},
  "metrics": [
    {
      "metricName": ""
    }
  ],
  "offset": "",
  "orderBys": [
    {
      "desc": false,
      "dimension": {
        "dimensionName": "",
        "orderType": ""
      },
      "metric": {
        "metricName": ""
      }
    }
  ],
  "returnEntityQuota": false,
  "timeZone": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1beta/:entity:runAccessReport');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'dateRanges' => [
    [
        'endDate' => '',
        'startDate' => ''
    ]
  ],
  'dimensionFilter' => [
    'accessFilter' => [
        'betweenFilter' => [
                'fromValue' => [
                                'doubleValue' => '',
                                'int64Value' => ''
                ],
                'toValue' => [
                                
                ]
        ],
        'fieldName' => '',
        'inListFilter' => [
                'caseSensitive' => null,
                'values' => [
                                
                ]
        ],
        'numericFilter' => [
                'operation' => '',
                'value' => [
                                
                ]
        ],
        'stringFilter' => [
                'caseSensitive' => null,
                'matchType' => '',
                'value' => ''
        ]
    ],
    'andGroup' => [
        'expressions' => [
                
        ]
    ],
    'notExpression' => '',
    'orGroup' => [
        
    ]
  ],
  'dimensions' => [
    [
        'dimensionName' => ''
    ]
  ],
  'limit' => '',
  'metricFilter' => [
    
  ],
  'metrics' => [
    [
        'metricName' => ''
    ]
  ],
  'offset' => '',
  'orderBys' => [
    [
        'desc' => null,
        'dimension' => [
                'dimensionName' => '',
                'orderType' => ''
        ],
        'metric' => [
                'metricName' => ''
        ]
    ]
  ],
  'returnEntityQuota' => null,
  'timeZone' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'dateRanges' => [
    [
        'endDate' => '',
        'startDate' => ''
    ]
  ],
  'dimensionFilter' => [
    'accessFilter' => [
        'betweenFilter' => [
                'fromValue' => [
                                'doubleValue' => '',
                                'int64Value' => ''
                ],
                'toValue' => [
                                
                ]
        ],
        'fieldName' => '',
        'inListFilter' => [
                'caseSensitive' => null,
                'values' => [
                                
                ]
        ],
        'numericFilter' => [
                'operation' => '',
                'value' => [
                                
                ]
        ],
        'stringFilter' => [
                'caseSensitive' => null,
                'matchType' => '',
                'value' => ''
        ]
    ],
    'andGroup' => [
        'expressions' => [
                
        ]
    ],
    'notExpression' => '',
    'orGroup' => [
        
    ]
  ],
  'dimensions' => [
    [
        'dimensionName' => ''
    ]
  ],
  'limit' => '',
  'metricFilter' => [
    
  ],
  'metrics' => [
    [
        'metricName' => ''
    ]
  ],
  'offset' => '',
  'orderBys' => [
    [
        'desc' => null,
        'dimension' => [
                'dimensionName' => '',
                'orderType' => ''
        ],
        'metric' => [
                'metricName' => ''
        ]
    ]
  ],
  'returnEntityQuota' => null,
  'timeZone' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1beta/:entity:runAccessReport');
$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/:entity:runAccessReport' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "dateRanges": [
    {
      "endDate": "",
      "startDate": ""
    }
  ],
  "dimensionFilter": {
    "accessFilter": {
      "betweenFilter": {
        "fromValue": {
          "doubleValue": "",
          "int64Value": ""
        },
        "toValue": {}
      },
      "fieldName": "",
      "inListFilter": {
        "caseSensitive": false,
        "values": []
      },
      "numericFilter": {
        "operation": "",
        "value": {}
      },
      "stringFilter": {
        "caseSensitive": false,
        "matchType": "",
        "value": ""
      }
    },
    "andGroup": {
      "expressions": []
    },
    "notExpression": "",
    "orGroup": {}
  },
  "dimensions": [
    {
      "dimensionName": ""
    }
  ],
  "limit": "",
  "metricFilter": {},
  "metrics": [
    {
      "metricName": ""
    }
  ],
  "offset": "",
  "orderBys": [
    {
      "desc": false,
      "dimension": {
        "dimensionName": "",
        "orderType": ""
      },
      "metric": {
        "metricName": ""
      }
    }
  ],
  "returnEntityQuota": false,
  "timeZone": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1beta/:entity:runAccessReport' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "dateRanges": [
    {
      "endDate": "",
      "startDate": ""
    }
  ],
  "dimensionFilter": {
    "accessFilter": {
      "betweenFilter": {
        "fromValue": {
          "doubleValue": "",
          "int64Value": ""
        },
        "toValue": {}
      },
      "fieldName": "",
      "inListFilter": {
        "caseSensitive": false,
        "values": []
      },
      "numericFilter": {
        "operation": "",
        "value": {}
      },
      "stringFilter": {
        "caseSensitive": false,
        "matchType": "",
        "value": ""
      }
    },
    "andGroup": {
      "expressions": []
    },
    "notExpression": "",
    "orGroup": {}
  },
  "dimensions": [
    {
      "dimensionName": ""
    }
  ],
  "limit": "",
  "metricFilter": {},
  "metrics": [
    {
      "metricName": ""
    }
  ],
  "offset": "",
  "orderBys": [
    {
      "desc": false,
      "dimension": {
        "dimensionName": "",
        "orderType": ""
      },
      "metric": {
        "metricName": ""
      }
    }
  ],
  "returnEntityQuota": false,
  "timeZone": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1beta/:entity:runAccessReport", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1beta/:entity:runAccessReport"

payload = {
    "dateRanges": [
        {
            "endDate": "",
            "startDate": ""
        }
    ],
    "dimensionFilter": {
        "accessFilter": {
            "betweenFilter": {
                "fromValue": {
                    "doubleValue": "",
                    "int64Value": ""
                },
                "toValue": {}
            },
            "fieldName": "",
            "inListFilter": {
                "caseSensitive": False,
                "values": []
            },
            "numericFilter": {
                "operation": "",
                "value": {}
            },
            "stringFilter": {
                "caseSensitive": False,
                "matchType": "",
                "value": ""
            }
        },
        "andGroup": { "expressions": [] },
        "notExpression": "",
        "orGroup": {}
    },
    "dimensions": [{ "dimensionName": "" }],
    "limit": "",
    "metricFilter": {},
    "metrics": [{ "metricName": "" }],
    "offset": "",
    "orderBys": [
        {
            "desc": False,
            "dimension": {
                "dimensionName": "",
                "orderType": ""
            },
            "metric": { "metricName": "" }
        }
    ],
    "returnEntityQuota": False,
    "timeZone": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1beta/:entity:runAccessReport"

payload <- "{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1beta/:entity:runAccessReport")

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  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1beta/:entity:runAccessReport') do |req|
  req.body = "{\n  \"dateRanges\": [\n    {\n      \"endDate\": \"\",\n      \"startDate\": \"\"\n    }\n  ],\n  \"dimensionFilter\": {\n    \"accessFilter\": {\n      \"betweenFilter\": {\n        \"fromValue\": {\n          \"doubleValue\": \"\",\n          \"int64Value\": \"\"\n        },\n        \"toValue\": {}\n      },\n      \"fieldName\": \"\",\n      \"inListFilter\": {\n        \"caseSensitive\": false,\n        \"values\": []\n      },\n      \"numericFilter\": {\n        \"operation\": \"\",\n        \"value\": {}\n      },\n      \"stringFilter\": {\n        \"caseSensitive\": false,\n        \"matchType\": \"\",\n        \"value\": \"\"\n      }\n    },\n    \"andGroup\": {\n      \"expressions\": []\n    },\n    \"notExpression\": \"\",\n    \"orGroup\": {}\n  },\n  \"dimensions\": [\n    {\n      \"dimensionName\": \"\"\n    }\n  ],\n  \"limit\": \"\",\n  \"metricFilter\": {},\n  \"metrics\": [\n    {\n      \"metricName\": \"\"\n    }\n  ],\n  \"offset\": \"\",\n  \"orderBys\": [\n    {\n      \"desc\": false,\n      \"dimension\": {\n        \"dimensionName\": \"\",\n        \"orderType\": \"\"\n      },\n      \"metric\": {\n        \"metricName\": \"\"\n      }\n    }\n  ],\n  \"returnEntityQuota\": false,\n  \"timeZone\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1beta/:entity:runAccessReport";

    let payload = json!({
        "dateRanges": (
            json!({
                "endDate": "",
                "startDate": ""
            })
        ),
        "dimensionFilter": json!({
            "accessFilter": json!({
                "betweenFilter": json!({
                    "fromValue": json!({
                        "doubleValue": "",
                        "int64Value": ""
                    }),
                    "toValue": json!({})
                }),
                "fieldName": "",
                "inListFilter": json!({
                    "caseSensitive": false,
                    "values": ()
                }),
                "numericFilter": json!({
                    "operation": "",
                    "value": json!({})
                }),
                "stringFilter": json!({
                    "caseSensitive": false,
                    "matchType": "",
                    "value": ""
                })
            }),
            "andGroup": json!({"expressions": ()}),
            "notExpression": "",
            "orGroup": json!({})
        }),
        "dimensions": (json!({"dimensionName": ""})),
        "limit": "",
        "metricFilter": json!({}),
        "metrics": (json!({"metricName": ""})),
        "offset": "",
        "orderBys": (
            json!({
                "desc": false,
                "dimension": json!({
                    "dimensionName": "",
                    "orderType": ""
                }),
                "metric": json!({"metricName": ""})
            })
        ),
        "returnEntityQuota": false,
        "timeZone": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/v1beta/:entity:runAccessReport \
  --header 'content-type: application/json' \
  --data '{
  "dateRanges": [
    {
      "endDate": "",
      "startDate": ""
    }
  ],
  "dimensionFilter": {
    "accessFilter": {
      "betweenFilter": {
        "fromValue": {
          "doubleValue": "",
          "int64Value": ""
        },
        "toValue": {}
      },
      "fieldName": "",
      "inListFilter": {
        "caseSensitive": false,
        "values": []
      },
      "numericFilter": {
        "operation": "",
        "value": {}
      },
      "stringFilter": {
        "caseSensitive": false,
        "matchType": "",
        "value": ""
      }
    },
    "andGroup": {
      "expressions": []
    },
    "notExpression": "",
    "orGroup": {}
  },
  "dimensions": [
    {
      "dimensionName": ""
    }
  ],
  "limit": "",
  "metricFilter": {},
  "metrics": [
    {
      "metricName": ""
    }
  ],
  "offset": "",
  "orderBys": [
    {
      "desc": false,
      "dimension": {
        "dimensionName": "",
        "orderType": ""
      },
      "metric": {
        "metricName": ""
      }
    }
  ],
  "returnEntityQuota": false,
  "timeZone": ""
}'

echo '{
  "dateRanges": [
    {
      "endDate": "",
      "startDate": ""
    }
  ],
  "dimensionFilter": {
    "accessFilter": {
      "betweenFilter": {
        "fromValue": {
          "doubleValue": "",
          "int64Value": ""
        },
        "toValue": {}
      },
      "fieldName": "",
      "inListFilter": {
        "caseSensitive": false,
        "values": []
      },
      "numericFilter": {
        "operation": "",
        "value": {}
      },
      "stringFilter": {
        "caseSensitive": false,
        "matchType": "",
        "value": ""
      }
    },
    "andGroup": {
      "expressions": []
    },
    "notExpression": "",
    "orGroup": {}
  },
  "dimensions": [
    {
      "dimensionName": ""
    }
  ],
  "limit": "",
  "metricFilter": {},
  "metrics": [
    {
      "metricName": ""
    }
  ],
  "offset": "",
  "orderBys": [
    {
      "desc": false,
      "dimension": {
        "dimensionName": "",
        "orderType": ""
      },
      "metric": {
        "metricName": ""
      }
    }
  ],
  "returnEntityQuota": false,
  "timeZone": ""
}' |  \
  http POST {{baseUrl}}/v1beta/:entity:runAccessReport \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "dateRanges": [\n    {\n      "endDate": "",\n      "startDate": ""\n    }\n  ],\n  "dimensionFilter": {\n    "accessFilter": {\n      "betweenFilter": {\n        "fromValue": {\n          "doubleValue": "",\n          "int64Value": ""\n        },\n        "toValue": {}\n      },\n      "fieldName": "",\n      "inListFilter": {\n        "caseSensitive": false,\n        "values": []\n      },\n      "numericFilter": {\n        "operation": "",\n        "value": {}\n      },\n      "stringFilter": {\n        "caseSensitive": false,\n        "matchType": "",\n        "value": ""\n      }\n    },\n    "andGroup": {\n      "expressions": []\n    },\n    "notExpression": "",\n    "orGroup": {}\n  },\n  "dimensions": [\n    {\n      "dimensionName": ""\n    }\n  ],\n  "limit": "",\n  "metricFilter": {},\n  "metrics": [\n    {\n      "metricName": ""\n    }\n  ],\n  "offset": "",\n  "orderBys": [\n    {\n      "desc": false,\n      "dimension": {\n        "dimensionName": "",\n        "orderType": ""\n      },\n      "metric": {\n        "metricName": ""\n      }\n    }\n  ],\n  "returnEntityQuota": false,\n  "timeZone": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1beta/:entity:runAccessReport

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "dateRanges": [
    [
      "endDate": "",
      "startDate": ""
    ]
  ],
  "dimensionFilter": [
    "accessFilter": [
      "betweenFilter": [
        "fromValue": [
          "doubleValue": "",
          "int64Value": ""
        ],
        "toValue": []
      ],
      "fieldName": "",
      "inListFilter": [
        "caseSensitive": false,
        "values": []
      ],
      "numericFilter": [
        "operation": "",
        "value": []
      ],
      "stringFilter": [
        "caseSensitive": false,
        "matchType": "",
        "value": ""
      ]
    ],
    "andGroup": ["expressions": []],
    "notExpression": "",
    "orGroup": []
  ],
  "dimensions": [["dimensionName": ""]],
  "limit": "",
  "metricFilter": [],
  "metrics": [["metricName": ""]],
  "offset": "",
  "orderBys": [
    [
      "desc": false,
      "dimension": [
        "dimensionName": "",
        "orderType": ""
      ],
      "metric": ["metricName": ""]
    ]
  ],
  "returnEntityQuota": false,
  "timeZone": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1beta/:entity:runAccessReport")! 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()