CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/user/analytics/:storeId")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId"

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

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId"

	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/v2/user/analytics/:storeId HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId"))
    .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}}/v2/user/analytics/:storeId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/analytics/:storeId")
  .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}}/v2/user/analytics/:storeId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/user/analytics/:storeId'};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId';
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}}/v2/user/analytics/:storeId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/:storeId');

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}}/v2/user/analytics/:storeId'};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId';
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}}/v2/user/analytics/:storeId"]
                                                       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}}/v2/user/analytics/:storeId" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId",
  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}}/v2/user/analytics/:storeId');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v2/user/analytics/:storeId")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId")

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/v2/user/analytics/:storeId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/analytics/:storeId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/user/analytics/")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v2/user/analytics/'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/');

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}}/v2/user/analytics/'};

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

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

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

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

 "{{baseUrl}}/v2/user/analytics/",
  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}}/v2/user/analytics/');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v2/user/analytics/")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/")

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/v2/user/analytics/') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/analytics/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/

import Foundation

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

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy");

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  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy" {:content-type :json
                                                                                          :form-params {:channelIdSource ""
                                                                                                        :channelIdTarget ""
                                                                                                        :keepExistingOptimisation false}})

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy"),
    Content = new StringContent("{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy"

	payload := strings.NewReader("{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}")

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

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/optimisations/copy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 89

{
  "channelIdSource": "",
  "channelIdTarget": "",
  "keepExistingOptimisation": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy")
  .header("content-type", "application/json")
  .body("{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}")
  .asString();

const data = JSON.stringify({
  channelIdSource: '',
  channelIdTarget: '',
  keepExistingOptimisation: false
});

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy',
  headers: {'content-type': 'application/json'},
  data: {channelIdSource: '', channelIdTarget: '', keepExistingOptimisation: false}
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"channelIdSource":"","channelIdTarget":"","keepExistingOptimisation":false}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "channelIdSource": "",\n  "channelIdTarget": "",\n  "keepExistingOptimisation": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy")
  .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/v2/user/analytics/:storeId/optimisations/copy',
  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({channelIdSource: '', channelIdTarget: '', keepExistingOptimisation: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy',
  headers: {'content-type': 'application/json'},
  body: {channelIdSource: '', channelIdTarget: '', keepExistingOptimisation: false},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy');

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

req.type('json');
req.send({
  channelIdSource: '',
  channelIdTarget: '',
  keepExistingOptimisation: false
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy',
  headers: {'content-type': 'application/json'},
  data: {channelIdSource: '', channelIdTarget: '', keepExistingOptimisation: false}
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"channelIdSource":"","channelIdTarget":"","keepExistingOptimisation":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"channelIdSource": @"",
                              @"channelIdTarget": @"",
                              @"keepExistingOptimisation": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy"]
                                                       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}}/v2/user/analytics/:storeId/optimisations/copy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy",
  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([
    'channelIdSource' => '',
    'channelIdTarget' => '',
    'keepExistingOptimisation' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy', [
  'body' => '{
  "channelIdSource": "",
  "channelIdTarget": "",
  "keepExistingOptimisation": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'channelIdSource' => '',
  'channelIdTarget' => '',
  'keepExistingOptimisation' => null
]));

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

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

append(json_encode([
  'channelIdSource' => '',
  'channelIdTarget' => '',
  'keepExistingOptimisation' => null
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy');
$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}}/v2/user/analytics/:storeId/optimisations/copy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "channelIdSource": "",
  "channelIdTarget": "",
  "keepExistingOptimisation": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "channelIdSource": "",
  "channelIdTarget": "",
  "keepExistingOptimisation": false
}'

import http.client

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

payload = "{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}"

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/optimisations/copy", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy"

payload = {
    "channelIdSource": "",
    "channelIdTarget": "",
    "keepExistingOptimisation": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy"

payload <- "{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy")

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  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/optimisations/copy') do |req|
  req.body = "{\n  \"channelIdSource\": \"\",\n  \"channelIdTarget\": \"\",\n  \"keepExistingOptimisation\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy";

    let payload = json!({
        "channelIdSource": "",
        "channelIdTarget": "",
        "keepExistingOptimisation": false
    });

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

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

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

    dbg!(results);
}

echo '{
  "channelIdSource": "",
  "channelIdTarget": "",
  "keepExistingOptimisation": false
}' |  \
  http POST {{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "channelIdSource": "",\n  "channelIdTarget": "",\n  "keepExistingOptimisation": false\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "channelIdSource": "",
  "channelIdTarget": "",
  "keepExistingOptimisation": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/copy")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName"

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/optimisations/all/:actionName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/optimisations/all/:actionName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName');

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}}/v2/user/analytics/:storeId/optimisations/all/:actionName'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/optimisations/all/:actionName")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/optimisations/all/:actionName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/all/:actionName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName");

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  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName" {:content-type :json
                                                                                                                      :form-params ["a2d38563-50f0-43f1-be2b-b16e7ec4f007"]})

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName"),
    Content = new StringContent("[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName"

	payload := strings.NewReader("[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

[
  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName")
  .setHeader("content-type", "application/json")
  .setBody("[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName")
  .header("content-type", "application/json")
  .body("[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]")
  .asString();

const data = JSON.stringify([
  'a2d38563-50f0-43f1-be2b-b16e7ec4f007'
]);

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName',
  headers: {'content-type': 'application/json'},
  data: ['a2d38563-50f0-43f1-be2b-b16e7ec4f007']
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '["a2d38563-50f0-43f1-be2b-b16e7ec4f007"]'
};

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}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"\n]'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName")
  .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/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName',
  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(['a2d38563-50f0-43f1-be2b-b16e7ec4f007']));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName',
  headers: {'content-type': 'application/json'},
  body: ['a2d38563-50f0-43f1-be2b-b16e7ec4f007'],
  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}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName');

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

req.type('json');
req.send([
  'a2d38563-50f0-43f1-be2b-b16e7ec4f007'
]);

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}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName',
  headers: {'content-type': 'application/json'},
  data: ['a2d38563-50f0-43f1-be2b-b16e7ec4f007']
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '["a2d38563-50f0-43f1-be2b-b16e7ec4f007"]'
};

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 = @[ @"a2d38563-50f0-43f1-be2b-b16e7ec4f007" ];

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName"]
                                                       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}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName",
  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([
    'a2d38563-50f0-43f1-be2b-b16e7ec4f007'
  ]),
  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}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName', [
  'body' => '[
  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'a2d38563-50f0-43f1-be2b-b16e7ec4f007'
]));

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

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

append(json_encode([
  'a2d38563-50f0-43f1-be2b-b16e7ec4f007'
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName');
$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}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"
]'

import http.client

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

payload = "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]"

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName"

payload = ["a2d38563-50f0-43f1-be2b-b16e7ec4f007"]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName"

payload <- "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName")

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  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName') do |req|
  req.body = "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName";

    let payload = ("a2d38563-50f0-43f1-be2b-b16e7ec4f007");

    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);
}

echo '[
  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"
]' |  \
  http POST {{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"\n]' \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["a2d38563-50f0-43f1-be2b-b16e7ec4f007"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/byproduct/:productId/:actionName")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName");

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  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName" {:content-type :json
                                                                                                                               :form-params ["a2d38563-50f0-43f1-be2b-b16e7ec4f007"]})

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName"),
    Content = new StringContent("[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName"

	payload := strings.NewReader("[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

[
  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName")
  .setHeader("content-type", "application/json")
  .setBody("[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName")
  .header("content-type", "application/json")
  .body("[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]")
  .asString();

const data = JSON.stringify([
  'a2d38563-50f0-43f1-be2b-b16e7ec4f007'
]);

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName',
  headers: {'content-type': 'application/json'},
  data: ['a2d38563-50f0-43f1-be2b-b16e7ec4f007']
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '["a2d38563-50f0-43f1-be2b-b16e7ec4f007"]'
};

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}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"\n]'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName")
  .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/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName',
  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(['a2d38563-50f0-43f1-be2b-b16e7ec4f007']));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName',
  headers: {'content-type': 'application/json'},
  body: ['a2d38563-50f0-43f1-be2b-b16e7ec4f007'],
  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}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName');

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

req.type('json');
req.send([
  'a2d38563-50f0-43f1-be2b-b16e7ec4f007'
]);

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}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName',
  headers: {'content-type': 'application/json'},
  data: ['a2d38563-50f0-43f1-be2b-b16e7ec4f007']
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '["a2d38563-50f0-43f1-be2b-b16e7ec4f007"]'
};

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 = @[ @"a2d38563-50f0-43f1-be2b-b16e7ec4f007" ];

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName"]
                                                       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}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName",
  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([
    'a2d38563-50f0-43f1-be2b-b16e7ec4f007'
  ]),
  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}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName', [
  'body' => '[
  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'a2d38563-50f0-43f1-be2b-b16e7ec4f007'
]));

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

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

append(json_encode([
  'a2d38563-50f0-43f1-be2b-b16e7ec4f007'
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName');
$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}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"
]'

import http.client

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

payload = "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]"

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName"

payload = ["a2d38563-50f0-43f1-be2b-b16e7ec4f007"]
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName"

payload <- "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName")

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  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\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/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName') do |req|
  req.body = "[\n  \"a2d38563-50f0-43f1-be2b-b16e7ec4f007\"\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName";

    let payload = ("a2d38563-50f0-43f1-be2b-b16e7ec4f007");

    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);
}

echo '[
  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"
]' |  \
  http POST {{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  "a2d38563-50f0-43f1-be2b-b16e7ec4f007"\n]' \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["a2d38563-50f0-43f1-be2b-b16e7ec4f007"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bycategory/:catalogCategoryId/:actionName")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName"

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName');

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}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/bychannel/:channelId/:actionName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName"

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/optimisations/:actionName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/optimisations/:actionName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName');

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}}/v2/user/analytics/:storeId/optimisations/:actionName'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/optimisations/:actionName")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/optimisations/:actionName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/optimisations/:actionName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"

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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"

	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/v2/user/analytics/:storeId/reports/filters/:reportFilterId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"))
    .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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId';
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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/reports/filters/:reportFilterId',
  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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');

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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId';
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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"]
                                                       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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId",
  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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v2/user/analytics/:storeId/reports/filters/:reportFilterId")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")

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/v2/user/analytics/:storeId/reports/filters/:reportFilterId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId";

    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);
}

http DELETE {{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters"

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

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters"

	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/v2/user/analytics/:storeId/reports/filters HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters"))
    .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}}/v2/user/analytics/:storeId/reports/filters")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters")
  .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}}/v2/user/analytics/:storeId/reports/filters');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters';
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}}/v2/user/analytics/:storeId/reports/filters',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/reports/filters',
  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}}/v2/user/analytics/:storeId/reports/filters'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters');

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}}/v2/user/analytics/:storeId/reports/filters'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters';
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}}/v2/user/analytics/:storeId/reports/filters"]
                                                       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}}/v2/user/analytics/:storeId/reports/filters" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters",
  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}}/v2/user/analytics/:storeId/reports/filters');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/filters');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/filters');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v2/user/analytics/:storeId/reports/filters")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters")

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/v2/user/analytics/:storeId/reports/filters') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/analytics/:storeId/reports/filters

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/reports/filters

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"

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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"

	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/v2/user/analytics/:storeId/reports/filters/:reportFilterId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"))
    .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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId';
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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/reports/filters/:reportFilterId',
  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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');

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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId';
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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"]
                                                       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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId",
  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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v2/user/analytics/:storeId/reports/filters/:reportFilterId")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")

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/v2/user/analytics/:storeId/reports/filters/:reportFilterId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId");

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  \"reportFilterName\": \"My report filter\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId" {:content-type :json
                                                                                                      :form-params {:reportFilterName "My report filter"}})

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"reportFilterName\": \"My report filter\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"),
    Content = new StringContent("{\n  \"reportFilterName\": \"My report filter\"\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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"reportFilterName\": \"My report filter\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"

	payload := strings.NewReader("{\n  \"reportFilterName\": \"My report filter\"\n}")

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

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

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

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

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

}

PUT /baseUrl/v2/user/analytics/:storeId/reports/filters/:reportFilterId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "reportFilterName": "My report filter"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"reportFilterName\": \"My report filter\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"reportFilterName\": \"My report filter\"\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  \"reportFilterName\": \"My report filter\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .header("content-type", "application/json")
  .body("{\n  \"reportFilterName\": \"My report filter\"\n}")
  .asString();

const data = JSON.stringify({
  reportFilterName: 'My report filter'
});

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

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

xhr.open('PUT', '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId',
  headers: {'content-type': 'application/json'},
  data: {reportFilterName: 'My report filter'}
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"reportFilterName":"My report filter"}'
};

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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "reportFilterName": "My report filter"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"reportFilterName\": \"My report filter\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/reports/filters/:reportFilterId',
  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({reportFilterName: 'My report filter'}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId',
  headers: {'content-type': 'application/json'},
  body: {reportFilterName: 'My report filter'},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');

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

req.type('json');
req.send({
  reportFilterName: 'My report filter'
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId',
  headers: {'content-type': 'application/json'},
  data: {reportFilterName: 'My report filter'}
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"reportFilterName":"My report filter"}'
};

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 = @{ @"reportFilterName": @"My report filter" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"reportFilterName\": \"My report filter\"\n}" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'reportFilterName' => 'My report filter'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId', [
  'body' => '{
  "reportFilterName": "My report filter"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'reportFilterName' => 'My report filter'
]));

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

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

append(json_encode([
  'reportFilterName' => 'My report filter'
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "reportFilterName": "My report filter"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "reportFilterName": "My report filter"
}'

import http.client

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

payload = "{\n  \"reportFilterName\": \"My report filter\"\n}"

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

conn.request("PUT", "/baseUrl/v2/user/analytics/:storeId/reports/filters/:reportFilterId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"

payload = { "reportFilterName": "My report filter" }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId"

payload <- "{\n  \"reportFilterName\": \"My report filter\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"reportFilterName\": \"My report filter\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/v2/user/analytics/:storeId/reports/filters/:reportFilterId') do |req|
  req.body = "{\n  \"reportFilterName\": \"My report filter\"\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}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId";

    let payload = json!({"reportFilterName": "My report filter"});

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

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

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

    dbg!(results);
}

echo '{
  "reportFilterName": "My report filter"
}' |  \
  http PUT {{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "reportFilterName": "My report filter"\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/reports/filters/:reportFilterId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"

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

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"

	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/v2/user/analytics/:storeId/rules/:ruleId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"))
    .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}}/v2/user/analytics/:storeId/rules/:ruleId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")
  .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}}/v2/user/analytics/:storeId/rules/:ruleId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId';
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}}/v2/user/analytics/:storeId/rules/:ruleId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/rules/:ruleId',
  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}}/v2/user/analytics/:storeId/rules/:ruleId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId');

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}}/v2/user/analytics/:storeId/rules/:ruleId'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId';
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}}/v2/user/analytics/:storeId/rules/:ruleId"]
                                                       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}}/v2/user/analytics/:storeId/rules/:ruleId" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId",
  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}}/v2/user/analytics/:storeId/rules/:ruleId');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/v2/user/analytics/:storeId/rules/:ruleId")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")

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/v2/user/analytics/:storeId/rules/:ruleId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId";

    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);
}

http DELETE {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable"

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/rules/:ruleId/disable HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/disable',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable');

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}}/v2/user/analytics/:storeId/rules/:ruleId/disable'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/disable")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/disable') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/disable")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable"

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/rules/:ruleId/enable HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/enable',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable');

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}}/v2/user/analytics/:storeId/rules/:ruleId/enable'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/enable")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/enable') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/enable")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/user/analytics/:storeId/rules/executions" {:query-params {:pageNumber ""
                                                                                                      :pageSize ""}})

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize="

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}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize="

	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/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize="))
    .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}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=")
  .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}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/executions',
  params: {pageNumber: '', pageSize: ''}
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=';
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}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=',
  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}}/v2/user/analytics/:storeId/rules/executions',
  qs: {pageNumber: '', pageSize: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/:storeId/rules/executions');

req.query({
  pageNumber: '',
  pageSize: ''
});

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}}/v2/user/analytics/:storeId/rules/executions',
  params: {pageNumber: '', pageSize: ''}
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=';
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}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize="]
                                                       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}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=",
  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}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/executions');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'pageNumber' => '',
  'pageSize' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/executions');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'pageNumber' => '',
  'pageSize' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/executions"

querystring = {"pageNumber":"","pageSize":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules/executions"

queryString <- list(
  pageNumber = "",
  pageSize = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=")

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/v2/user/analytics/:storeId/rules/executions') do |req|
  req.params['pageNumber'] = ''
  req.params['pageSize'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/executions";

    let querystring = [
        ("pageNumber", ""),
        ("pageSize", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules/executions?pageNumber=&pageSize=")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/user/analytics/:storeId/rules")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules"

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

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/rules");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules"

	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/v2/user/analytics/:storeId/rules HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/analytics/:storeId/rules")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules"))
    .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}}/v2/user/analytics/:storeId/rules")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/analytics/:storeId/rules")
  .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}}/v2/user/analytics/:storeId/rules');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules';
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}}/v2/user/analytics/:storeId/rules',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/:storeId/rules');

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}}/v2/user/analytics/:storeId/rules'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules';
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}}/v2/user/analytics/:storeId/rules"]
                                                       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}}/v2/user/analytics/:storeId/rules" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules",
  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}}/v2/user/analytics/:storeId/rules');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v2/user/analytics/:storeId/rules")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/rules")

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/v2/user/analytics/:storeId/rules') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/rules";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/analytics/:storeId/rules

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/rules

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"

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

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"

	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/v2/user/analytics/:storeId/rules/:ruleId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"))
    .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}}/v2/user/analytics/:storeId/rules/:ruleId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")
  .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}}/v2/user/analytics/:storeId/rules/:ruleId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId';
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}}/v2/user/analytics/:storeId/rules/:ruleId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/rules/:ruleId',
  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}}/v2/user/analytics/:storeId/rules/:ruleId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId');

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}}/v2/user/analytics/:storeId/rules/:ruleId'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId';
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}}/v2/user/analytics/:storeId/rules/:ruleId"]
                                                       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}}/v2/user/analytics/:storeId/rules/:ruleId" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId",
  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}}/v2/user/analytics/:storeId/rules/:ruleId');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/v2/user/analytics/:storeId/rules/:ruleId")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")

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/v2/user/analytics/:storeId/rules/:ruleId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown"

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/rules/:ruleId/movedown HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/movedown',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown');

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}}/v2/user/analytics/:storeId/rules/:ruleId/movedown'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/movedown")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/movedown') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/movedown")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup"

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/rules/:ruleId/moveup HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/moveup',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup');

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}}/v2/user/analytics/:storeId/rules/:ruleId/moveup'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/moveup")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/moveup') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/moveup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules");

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  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/rules" {:content-type :json
                                                                             :form-params {:endUtcDate "2017-09-30T10:42:40.001Z"
                                                                                           :optimisationActionName "reenable"
                                                                                           :reportFilterId "fb19c53c-2f63-4262-9d94-2d7faa500acd"
                                                                                           :ruleName "My rule"
                                                                                           :startUtcDate "2016-08-29T09:12:33.001Z"}})

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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}}/v2/user/analytics/:storeId/rules"),
    Content = new StringContent("{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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}}/v2/user/analytics/:storeId/rules");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules"

	payload := strings.NewReader("{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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/v2/user/analytics/:storeId/rules HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 217

{
  "endUtcDate": "2017-09-30T10:42:40.001Z",
  "optimisationActionName": "reenable",
  "reportFilterId": "fb19c53c-2f63-4262-9d94-2d7faa500acd",
  "ruleName": "My rule",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/rules")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/rules")
  .header("content-type", "application/json")
  .body("{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}")
  .asString();

const data = JSON.stringify({
  endUtcDate: '2017-09-30T10:42:40.001Z',
  optimisationActionName: 'reenable',
  reportFilterId: 'fb19c53c-2f63-4262-9d94-2d7faa500acd',
  ruleName: 'My rule',
  startUtcDate: '2016-08-29T09:12:33.001Z'
});

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules',
  headers: {'content-type': 'application/json'},
  data: {
    endUtcDate: '2017-09-30T10:42:40.001Z',
    optimisationActionName: 'reenable',
    reportFilterId: 'fb19c53c-2f63-4262-9d94-2d7faa500acd',
    ruleName: 'My rule',
    startUtcDate: '2016-08-29T09:12:33.001Z'
  }
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"endUtcDate":"2017-09-30T10:42:40.001Z","optimisationActionName":"reenable","reportFilterId":"fb19c53c-2f63-4262-9d94-2d7faa500acd","ruleName":"My rule","startUtcDate":"2016-08-29T09:12:33.001Z"}'
};

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}}/v2/user/analytics/:storeId/rules',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "endUtcDate": "2017-09-30T10:42:40.001Z",\n  "optimisationActionName": "reenable",\n  "reportFilterId": "fb19c53c-2f63-4262-9d94-2d7faa500acd",\n  "ruleName": "My rule",\n  "startUtcDate": "2016-08-29T09:12:33.001Z"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules")
  .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/v2/user/analytics/:storeId/rules',
  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({
  endUtcDate: '2017-09-30T10:42:40.001Z',
  optimisationActionName: 'reenable',
  reportFilterId: 'fb19c53c-2f63-4262-9d94-2d7faa500acd',
  ruleName: 'My rule',
  startUtcDate: '2016-08-29T09:12:33.001Z'
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules',
  headers: {'content-type': 'application/json'},
  body: {
    endUtcDate: '2017-09-30T10:42:40.001Z',
    optimisationActionName: 'reenable',
    reportFilterId: 'fb19c53c-2f63-4262-9d94-2d7faa500acd',
    ruleName: 'My rule',
    startUtcDate: '2016-08-29T09:12:33.001Z'
  },
  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}}/v2/user/analytics/:storeId/rules');

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

req.type('json');
req.send({
  endUtcDate: '2017-09-30T10:42:40.001Z',
  optimisationActionName: 'reenable',
  reportFilterId: 'fb19c53c-2f63-4262-9d94-2d7faa500acd',
  ruleName: 'My rule',
  startUtcDate: '2016-08-29T09:12:33.001Z'
});

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}}/v2/user/analytics/:storeId/rules',
  headers: {'content-type': 'application/json'},
  data: {
    endUtcDate: '2017-09-30T10:42:40.001Z',
    optimisationActionName: 'reenable',
    reportFilterId: 'fb19c53c-2f63-4262-9d94-2d7faa500acd',
    ruleName: 'My rule',
    startUtcDate: '2016-08-29T09:12:33.001Z'
  }
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"endUtcDate":"2017-09-30T10:42:40.001Z","optimisationActionName":"reenable","reportFilterId":"fb19c53c-2f63-4262-9d94-2d7faa500acd","ruleName":"My rule","startUtcDate":"2016-08-29T09:12:33.001Z"}'
};

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 = @{ @"endUtcDate": @"2017-09-30T10:42:40.001Z",
                              @"optimisationActionName": @"reenable",
                              @"reportFilterId": @"fb19c53c-2f63-4262-9d94-2d7faa500acd",
                              @"ruleName": @"My rule",
                              @"startUtcDate": @"2016-08-29T09:12:33.001Z" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/rules"]
                                                       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}}/v2/user/analytics/:storeId/rules" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules",
  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([
    'endUtcDate' => '2017-09-30T10:42:40.001Z',
    'optimisationActionName' => 'reenable',
    'reportFilterId' => 'fb19c53c-2f63-4262-9d94-2d7faa500acd',
    'ruleName' => 'My rule',
    'startUtcDate' => '2016-08-29T09:12:33.001Z'
  ]),
  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}}/v2/user/analytics/:storeId/rules', [
  'body' => '{
  "endUtcDate": "2017-09-30T10:42:40.001Z",
  "optimisationActionName": "reenable",
  "reportFilterId": "fb19c53c-2f63-4262-9d94-2d7faa500acd",
  "ruleName": "My rule",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'endUtcDate' => '2017-09-30T10:42:40.001Z',
  'optimisationActionName' => 'reenable',
  'reportFilterId' => 'fb19c53c-2f63-4262-9d94-2d7faa500acd',
  'ruleName' => 'My rule',
  'startUtcDate' => '2016-08-29T09:12:33.001Z'
]));

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

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

append(json_encode([
  'endUtcDate' => '2017-09-30T10:42:40.001Z',
  'optimisationActionName' => 'reenable',
  'reportFilterId' => 'fb19c53c-2f63-4262-9d94-2d7faa500acd',
  'ruleName' => 'My rule',
  'startUtcDate' => '2016-08-29T09:12:33.001Z'
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules');
$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}}/v2/user/analytics/:storeId/rules' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "endUtcDate": "2017-09-30T10:42:40.001Z",
  "optimisationActionName": "reenable",
  "reportFilterId": "fb19c53c-2f63-4262-9d94-2d7faa500acd",
  "ruleName": "My rule",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "endUtcDate": "2017-09-30T10:42:40.001Z",
  "optimisationActionName": "reenable",
  "reportFilterId": "fb19c53c-2f63-4262-9d94-2d7faa500acd",
  "ruleName": "My rule",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
}'

import http.client

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

payload = "{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}"

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/rules", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules"

payload = {
    "endUtcDate": "2017-09-30T10:42:40.001Z",
    "optimisationActionName": "reenable",
    "reportFilterId": "fb19c53c-2f63-4262-9d94-2d7faa500acd",
    "ruleName": "My rule",
    "startUtcDate": "2016-08-29T09:12:33.001Z"
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules"

payload <- "{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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}}/v2/user/analytics/:storeId/rules")

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  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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/v2/user/analytics/:storeId/rules') do |req|
  req.body = "{\n  \"endUtcDate\": \"2017-09-30T10:42:40.001Z\",\n  \"optimisationActionName\": \"reenable\",\n  \"reportFilterId\": \"fb19c53c-2f63-4262-9d94-2d7faa500acd\",\n  \"ruleName\": \"My rule\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/rules";

    let payload = json!({
        "endUtcDate": "2017-09-30T10:42:40.001Z",
        "optimisationActionName": "reenable",
        "reportFilterId": "fb19c53c-2f63-4262-9d94-2d7faa500acd",
        "ruleName": "My rule",
        "startUtcDate": "2016-08-29T09:12:33.001Z"
    });

    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);
}

echo '{
  "endUtcDate": "2017-09-30T10:42:40.001Z",
  "optimisationActionName": "reenable",
  "reportFilterId": "fb19c53c-2f63-4262-9d94-2d7faa500acd",
  "ruleName": "My rule",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
}' |  \
  http POST {{baseUrl}}/v2/user/analytics/:storeId/rules \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "endUtcDate": "2017-09-30T10:42:40.001Z",\n  "optimisationActionName": "reenable",\n  "reportFilterId": "fb19c53c-2f63-4262-9d94-2d7faa500acd",\n  "ruleName": "My rule",\n  "startUtcDate": "2016-08-29T09:12:33.001Z"\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/rules

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "endUtcDate": "2017-09-30T10:42:40.001Z",
  "optimisationActionName": "reenable",
  "reportFilterId": "fb19c53c-2f63-4262-9d94-2d7faa500acd",
  "ruleName": "My rule",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules/run");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/rules/run")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/run"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/rules/run"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/rules/run");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules/run"

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/rules/run HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/rules/run")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules/run"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/run")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/rules/run")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/run');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/run'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/run';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/run',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/run")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/rules/run',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/run'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/run');

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}}/v2/user/analytics/:storeId/rules/run'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/run';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/rules/run"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/rules/run" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules/run",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/run');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/run');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/run');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/run' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/run' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/rules/run")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/run"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules/run"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/rules/run")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/rules/run') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/run";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/rules/run

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/rules/run

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules/run")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run"

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/rules/:ruleId/run HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/run',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run');

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}}/v2/user/analytics/:storeId/rules/:ruleId/run'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/run")

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/rules/:ruleId/run') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId/run")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId");

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  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId" {:content-type :json
                                                                                      :form-params {:endUtcDate "2016-08-29T09:12:33.001Z"
                                                                                                    :ruleName "My Rule Renamed"
                                                                                                    :startUtcDate "2016-08-29T09:12:33.001Z"}})

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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}}/v2/user/analytics/:storeId/rules/:ruleId"),
    Content = new StringContent("{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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}}/v2/user/analytics/:storeId/rules/:ruleId");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"

	payload := strings.NewReader("{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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/v2/user/analytics/:storeId/rules/:ruleId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 125

{
  "endUtcDate": "2016-08-29T09:12:33.001Z",
  "ruleName": "My Rule Renamed",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")
  .header("content-type", "application/json")
  .body("{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}")
  .asString();

const data = JSON.stringify({
  endUtcDate: '2016-08-29T09:12:33.001Z',
  ruleName: 'My Rule Renamed',
  startUtcDate: '2016-08-29T09:12:33.001Z'
});

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

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

xhr.open('PATCH', '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId',
  headers: {'content-type': 'application/json'},
  data: {
    endUtcDate: '2016-08-29T09:12:33.001Z',
    ruleName: 'My Rule Renamed',
    startUtcDate: '2016-08-29T09:12:33.001Z'
  }
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"endUtcDate":"2016-08-29T09:12:33.001Z","ruleName":"My Rule Renamed","startUtcDate":"2016-08-29T09:12:33.001Z"}'
};

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}}/v2/user/analytics/:storeId/rules/:ruleId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "endUtcDate": "2016-08-29T09:12:33.001Z",\n  "ruleName": "My Rule Renamed",\n  "startUtcDate": "2016-08-29T09:12:33.001Z"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")
  .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/v2/user/analytics/:storeId/rules/:ruleId',
  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({
  endUtcDate: '2016-08-29T09:12:33.001Z',
  ruleName: 'My Rule Renamed',
  startUtcDate: '2016-08-29T09:12:33.001Z'
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId',
  headers: {'content-type': 'application/json'},
  body: {
    endUtcDate: '2016-08-29T09:12:33.001Z',
    ruleName: 'My Rule Renamed',
    startUtcDate: '2016-08-29T09:12:33.001Z'
  },
  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}}/v2/user/analytics/:storeId/rules/:ruleId');

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

req.type('json');
req.send({
  endUtcDate: '2016-08-29T09:12:33.001Z',
  ruleName: 'My Rule Renamed',
  startUtcDate: '2016-08-29T09:12:33.001Z'
});

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}}/v2/user/analytics/:storeId/rules/:ruleId',
  headers: {'content-type': 'application/json'},
  data: {
    endUtcDate: '2016-08-29T09:12:33.001Z',
    ruleName: 'My Rule Renamed',
    startUtcDate: '2016-08-29T09:12:33.001Z'
  }
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"endUtcDate":"2016-08-29T09:12:33.001Z","ruleName":"My Rule Renamed","startUtcDate":"2016-08-29T09:12:33.001Z"}'
};

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 = @{ @"endUtcDate": @"2016-08-29T09:12:33.001Z",
                              @"ruleName": @"My Rule Renamed",
                              @"startUtcDate": @"2016-08-29T09:12:33.001Z" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"]
                                                       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}}/v2/user/analytics/:storeId/rules/:ruleId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId",
  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([
    'endUtcDate' => '2016-08-29T09:12:33.001Z',
    'ruleName' => 'My Rule Renamed',
    'startUtcDate' => '2016-08-29T09:12:33.001Z'
  ]),
  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}}/v2/user/analytics/:storeId/rules/:ruleId', [
  'body' => '{
  "endUtcDate": "2016-08-29T09:12:33.001Z",
  "ruleName": "My Rule Renamed",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'endUtcDate' => '2016-08-29T09:12:33.001Z',
  'ruleName' => 'My Rule Renamed',
  'startUtcDate' => '2016-08-29T09:12:33.001Z'
]));

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

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

append(json_encode([
  'endUtcDate' => '2016-08-29T09:12:33.001Z',
  'ruleName' => 'My Rule Renamed',
  'startUtcDate' => '2016-08-29T09:12:33.001Z'
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId');
$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}}/v2/user/analytics/:storeId/rules/:ruleId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "endUtcDate": "2016-08-29T09:12:33.001Z",
  "ruleName": "My Rule Renamed",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "endUtcDate": "2016-08-29T09:12:33.001Z",
  "ruleName": "My Rule Renamed",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
}'

import http.client

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

payload = "{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\n}"

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

conn.request("PATCH", "/baseUrl/v2/user/analytics/:storeId/rules/:ruleId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"

payload = {
    "endUtcDate": "2016-08-29T09:12:33.001Z",
    "ruleName": "My Rule Renamed",
    "startUtcDate": "2016-08-29T09:12:33.001Z"
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId"

payload <- "{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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}}/v2/user/analytics/:storeId/rules/:ruleId")

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  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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/v2/user/analytics/:storeId/rules/:ruleId') do |req|
  req.body = "{\n  \"endUtcDate\": \"2016-08-29T09:12:33.001Z\",\n  \"ruleName\": \"My Rule Renamed\",\n  \"startUtcDate\": \"2016-08-29T09:12:33.001Z\"\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}}/v2/user/analytics/:storeId/rules/:ruleId";

    let payload = json!({
        "endUtcDate": "2016-08-29T09:12:33.001Z",
        "ruleName": "My Rule Renamed",
        "startUtcDate": "2016-08-29T09:12:33.001Z"
    });

    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);
}

echo '{
  "endUtcDate": "2016-08-29T09:12:33.001Z",
  "ruleName": "My Rule Renamed",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
}' |  \
  http PATCH {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "endUtcDate": "2016-08-29T09:12:33.001Z",\n  "ruleName": "My Rule Renamed",\n  "startUtcDate": "2016-08-29T09:12:33.001Z"\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "endUtcDate": "2016-08-29T09:12:33.001Z",
  "ruleName": "My Rule Renamed",
  "startUtcDate": "2016-08-29T09:12:33.001Z"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/rules/:ruleId")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory"

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/reports/bycategory HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/reports/bycategory',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory');

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}}/v2/user/analytics/:storeId/reports/bycategory'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory' -Method POST 

import http.client

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

payload = ""

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/reports/bycategory", payload)

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/reports/bycategory') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/reports/bycategory")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel"

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

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

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

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

}

POST /baseUrl/v2/user/analytics/:storeId/reports/bychannel HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel'
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/reports/bychannel',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel');

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}}/v2/user/analytics/:storeId/reports/bychannel'
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel' -Method POST 

import http.client

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

payload = ""

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/reports/bychannel", payload)

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/v2/user/analytics/:storeId/reports/bychannel') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/reports/bychannel")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/reports/byday");

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  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/reports/byday" {:content-type :json
                                                                                     :form-params {:advancedFilters {:globalMarginPercent 0
                                                                                                                     :linkClickToOrderMaxDay 0
                                                                                                                     :linkClickToOrderType ""
                                                                                                                     :marginType ""
                                                                                                                     :onlyDirectSales false
                                                                                                                     :onlyPaymentValidatedOrders false
                                                                                                                     :performanceIndicatorFormula {:firstParameter ""
                                                                                                                                                   :operatorName ""
                                                                                                                                                   :secondParameter ""
                                                                                                                                                   :thirdParameter 0}}
                                                                                                   :beginPeriodUtcDate ""
                                                                                                   :catalogCategoryId ""
                                                                                                   :channelIds []
                                                                                                   :endPeriodUtcDate ""
                                                                                                   :productId ""}})

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/byday"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\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}}/v2/user/analytics/:storeId/reports/byday"),
    Content = new StringContent("{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\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}}/v2/user/analytics/:storeId/reports/byday");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/reports/byday"

	payload := strings.NewReader("{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\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/v2/user/analytics/:storeId/reports/byday HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 490

{
  "advancedFilters": {
    "globalMarginPercent": 0,
    "linkClickToOrderMaxDay": 0,
    "linkClickToOrderType": "",
    "marginType": "",
    "onlyDirectSales": false,
    "onlyPaymentValidatedOrders": false,
    "performanceIndicatorFormula": {
      "firstParameter": "",
      "operatorName": "",
      "secondParameter": "",
      "thirdParameter": 0
    }
  },
  "beginPeriodUtcDate": "",
  "catalogCategoryId": "",
  "channelIds": [],
  "endPeriodUtcDate": "",
  "productId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/reports/byday")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/reports/byday"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\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  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/byday")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/reports/byday")
  .header("content-type", "application/json")
  .body("{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  advancedFilters: {
    globalMarginPercent: 0,
    linkClickToOrderMaxDay: 0,
    linkClickToOrderType: '',
    marginType: '',
    onlyDirectSales: false,
    onlyPaymentValidatedOrders: false,
    performanceIndicatorFormula: {
      firstParameter: '',
      operatorName: '',
      secondParameter: '',
      thirdParameter: 0
    }
  },
  beginPeriodUtcDate: '',
  catalogCategoryId: '',
  channelIds: [],
  endPeriodUtcDate: '',
  productId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/reports/byday');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/byday',
  headers: {'content-type': 'application/json'},
  data: {
    advancedFilters: {
      globalMarginPercent: 0,
      linkClickToOrderMaxDay: 0,
      linkClickToOrderType: '',
      marginType: '',
      onlyDirectSales: false,
      onlyPaymentValidatedOrders: false,
      performanceIndicatorFormula: {firstParameter: '', operatorName: '', secondParameter: '', thirdParameter: 0}
    },
    beginPeriodUtcDate: '',
    catalogCategoryId: '',
    channelIds: [],
    endPeriodUtcDate: '',
    productId: ''
  }
};

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/byday';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"advancedFilters":{"globalMarginPercent":0,"linkClickToOrderMaxDay":0,"linkClickToOrderType":"","marginType":"","onlyDirectSales":false,"onlyPaymentValidatedOrders":false,"performanceIndicatorFormula":{"firstParameter":"","operatorName":"","secondParameter":"","thirdParameter":0}},"beginPeriodUtcDate":"","catalogCategoryId":"","channelIds":[],"endPeriodUtcDate":"","productId":""}'
};

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}}/v2/user/analytics/:storeId/reports/byday',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "advancedFilters": {\n    "globalMarginPercent": 0,\n    "linkClickToOrderMaxDay": 0,\n    "linkClickToOrderType": "",\n    "marginType": "",\n    "onlyDirectSales": false,\n    "onlyPaymentValidatedOrders": false,\n    "performanceIndicatorFormula": {\n      "firstParameter": "",\n      "operatorName": "",\n      "secondParameter": "",\n      "thirdParameter": 0\n    }\n  },\n  "beginPeriodUtcDate": "",\n  "catalogCategoryId": "",\n  "channelIds": [],\n  "endPeriodUtcDate": "",\n  "productId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/byday")
  .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/v2/user/analytics/:storeId/reports/byday',
  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({
  advancedFilters: {
    globalMarginPercent: 0,
    linkClickToOrderMaxDay: 0,
    linkClickToOrderType: '',
    marginType: '',
    onlyDirectSales: false,
    onlyPaymentValidatedOrders: false,
    performanceIndicatorFormula: {firstParameter: '', operatorName: '', secondParameter: '', thirdParameter: 0}
  },
  beginPeriodUtcDate: '',
  catalogCategoryId: '',
  channelIds: [],
  endPeriodUtcDate: '',
  productId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/byday',
  headers: {'content-type': 'application/json'},
  body: {
    advancedFilters: {
      globalMarginPercent: 0,
      linkClickToOrderMaxDay: 0,
      linkClickToOrderType: '',
      marginType: '',
      onlyDirectSales: false,
      onlyPaymentValidatedOrders: false,
      performanceIndicatorFormula: {firstParameter: '', operatorName: '', secondParameter: '', thirdParameter: 0}
    },
    beginPeriodUtcDate: '',
    catalogCategoryId: '',
    channelIds: [],
    endPeriodUtcDate: '',
    productId: ''
  },
  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}}/v2/user/analytics/:storeId/reports/byday');

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

req.type('json');
req.send({
  advancedFilters: {
    globalMarginPercent: 0,
    linkClickToOrderMaxDay: 0,
    linkClickToOrderType: '',
    marginType: '',
    onlyDirectSales: false,
    onlyPaymentValidatedOrders: false,
    performanceIndicatorFormula: {
      firstParameter: '',
      operatorName: '',
      secondParameter: '',
      thirdParameter: 0
    }
  },
  beginPeriodUtcDate: '',
  catalogCategoryId: '',
  channelIds: [],
  endPeriodUtcDate: '',
  productId: ''
});

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}}/v2/user/analytics/:storeId/reports/byday',
  headers: {'content-type': 'application/json'},
  data: {
    advancedFilters: {
      globalMarginPercent: 0,
      linkClickToOrderMaxDay: 0,
      linkClickToOrderType: '',
      marginType: '',
      onlyDirectSales: false,
      onlyPaymentValidatedOrders: false,
      performanceIndicatorFormula: {firstParameter: '', operatorName: '', secondParameter: '', thirdParameter: 0}
    },
    beginPeriodUtcDate: '',
    catalogCategoryId: '',
    channelIds: [],
    endPeriodUtcDate: '',
    productId: ''
  }
};

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

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

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/byday';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"advancedFilters":{"globalMarginPercent":0,"linkClickToOrderMaxDay":0,"linkClickToOrderType":"","marginType":"","onlyDirectSales":false,"onlyPaymentValidatedOrders":false,"performanceIndicatorFormula":{"firstParameter":"","operatorName":"","secondParameter":"","thirdParameter":0}},"beginPeriodUtcDate":"","catalogCategoryId":"","channelIds":[],"endPeriodUtcDate":"","productId":""}'
};

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 = @{ @"advancedFilters": @{ @"globalMarginPercent": @0, @"linkClickToOrderMaxDay": @0, @"linkClickToOrderType": @"", @"marginType": @"", @"onlyDirectSales": @NO, @"onlyPaymentValidatedOrders": @NO, @"performanceIndicatorFormula": @{ @"firstParameter": @"", @"operatorName": @"", @"secondParameter": @"", @"thirdParameter": @0 } },
                              @"beginPeriodUtcDate": @"",
                              @"catalogCategoryId": @"",
                              @"channelIds": @[  ],
                              @"endPeriodUtcDate": @"",
                              @"productId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/reports/byday"]
                                                       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}}/v2/user/analytics/:storeId/reports/byday" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\n}" in

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

 "{{baseUrl}}/v2/user/analytics/:storeId/reports/byday",
  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([
    'advancedFilters' => [
        'globalMarginPercent' => 0,
        'linkClickToOrderMaxDay' => 0,
        'linkClickToOrderType' => '',
        'marginType' => '',
        'onlyDirectSales' => null,
        'onlyPaymentValidatedOrders' => null,
        'performanceIndicatorFormula' => [
                'firstParameter' => '',
                'operatorName' => '',
                'secondParameter' => '',
                'thirdParameter' => 0
        ]
    ],
    'beginPeriodUtcDate' => '',
    'catalogCategoryId' => '',
    'channelIds' => [
        
    ],
    'endPeriodUtcDate' => '',
    'productId' => ''
  ]),
  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}}/v2/user/analytics/:storeId/reports/byday', [
  'body' => '{
  "advancedFilters": {
    "globalMarginPercent": 0,
    "linkClickToOrderMaxDay": 0,
    "linkClickToOrderType": "",
    "marginType": "",
    "onlyDirectSales": false,
    "onlyPaymentValidatedOrders": false,
    "performanceIndicatorFormula": {
      "firstParameter": "",
      "operatorName": "",
      "secondParameter": "",
      "thirdParameter": 0
    }
  },
  "beginPeriodUtcDate": "",
  "catalogCategoryId": "",
  "channelIds": [],
  "endPeriodUtcDate": "",
  "productId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/byday');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'advancedFilters' => [
    'globalMarginPercent' => 0,
    'linkClickToOrderMaxDay' => 0,
    'linkClickToOrderType' => '',
    'marginType' => '',
    'onlyDirectSales' => null,
    'onlyPaymentValidatedOrders' => null,
    'performanceIndicatorFormula' => [
        'firstParameter' => '',
        'operatorName' => '',
        'secondParameter' => '',
        'thirdParameter' => 0
    ]
  ],
  'beginPeriodUtcDate' => '',
  'catalogCategoryId' => '',
  'channelIds' => [
    
  ],
  'endPeriodUtcDate' => '',
  'productId' => ''
]));

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

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

append(json_encode([
  'advancedFilters' => [
    'globalMarginPercent' => 0,
    'linkClickToOrderMaxDay' => 0,
    'linkClickToOrderType' => '',
    'marginType' => '',
    'onlyDirectSales' => null,
    'onlyPaymentValidatedOrders' => null,
    'performanceIndicatorFormula' => [
        'firstParameter' => '',
        'operatorName' => '',
        'secondParameter' => '',
        'thirdParameter' => 0
    ]
  ],
  'beginPeriodUtcDate' => '',
  'catalogCategoryId' => '',
  'channelIds' => [
    
  ],
  'endPeriodUtcDate' => '',
  'productId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/byday');
$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}}/v2/user/analytics/:storeId/reports/byday' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "advancedFilters": {
    "globalMarginPercent": 0,
    "linkClickToOrderMaxDay": 0,
    "linkClickToOrderType": "",
    "marginType": "",
    "onlyDirectSales": false,
    "onlyPaymentValidatedOrders": false,
    "performanceIndicatorFormula": {
      "firstParameter": "",
      "operatorName": "",
      "secondParameter": "",
      "thirdParameter": 0
    }
  },
  "beginPeriodUtcDate": "",
  "catalogCategoryId": "",
  "channelIds": [],
  "endPeriodUtcDate": "",
  "productId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/byday' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "advancedFilters": {
    "globalMarginPercent": 0,
    "linkClickToOrderMaxDay": 0,
    "linkClickToOrderType": "",
    "marginType": "",
    "onlyDirectSales": false,
    "onlyPaymentValidatedOrders": false,
    "performanceIndicatorFormula": {
      "firstParameter": "",
      "operatorName": "",
      "secondParameter": "",
      "thirdParameter": 0
    }
  },
  "beginPeriodUtcDate": "",
  "catalogCategoryId": "",
  "channelIds": [],
  "endPeriodUtcDate": "",
  "productId": ""
}'

import http.client

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

payload = "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/reports/byday", payload, headers)

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

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

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/byday"

payload = {
    "advancedFilters": {
        "globalMarginPercent": 0,
        "linkClickToOrderMaxDay": 0,
        "linkClickToOrderType": "",
        "marginType": "",
        "onlyDirectSales": False,
        "onlyPaymentValidatedOrders": False,
        "performanceIndicatorFormula": {
            "firstParameter": "",
            "operatorName": "",
            "secondParameter": "",
            "thirdParameter": 0
        }
    },
    "beginPeriodUtcDate": "",
    "catalogCategoryId": "",
    "channelIds": [],
    "endPeriodUtcDate": "",
    "productId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/reports/byday"

payload <- "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\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}}/v2/user/analytics/:storeId/reports/byday")

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  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\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/v2/user/analytics/:storeId/reports/byday') do |req|
  req.body = "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": 0,\n    \"linkClickToOrderMaxDay\": 0,\n    \"linkClickToOrderType\": \"\",\n    \"marginType\": \"\",\n    \"onlyDirectSales\": false,\n    \"onlyPaymentValidatedOrders\": false,\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"\",\n      \"operatorName\": \"\",\n      \"secondParameter\": \"\",\n      \"thirdParameter\": 0\n    }\n  },\n  \"beginPeriodUtcDate\": \"\",\n  \"catalogCategoryId\": \"\",\n  \"channelIds\": [],\n  \"endPeriodUtcDate\": \"\",\n  \"productId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/byday";

    let payload = json!({
        "advancedFilters": json!({
            "globalMarginPercent": 0,
            "linkClickToOrderMaxDay": 0,
            "linkClickToOrderType": "",
            "marginType": "",
            "onlyDirectSales": false,
            "onlyPaymentValidatedOrders": false,
            "performanceIndicatorFormula": json!({
                "firstParameter": "",
                "operatorName": "",
                "secondParameter": "",
                "thirdParameter": 0
            })
        }),
        "beginPeriodUtcDate": "",
        "catalogCategoryId": "",
        "channelIds": (),
        "endPeriodUtcDate": "",
        "productId": ""
    });

    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);
}

echo '{
  "advancedFilters": {
    "globalMarginPercent": 0,
    "linkClickToOrderMaxDay": 0,
    "linkClickToOrderType": "",
    "marginType": "",
    "onlyDirectSales": false,
    "onlyPaymentValidatedOrders": false,
    "performanceIndicatorFormula": {
      "firstParameter": "",
      "operatorName": "",
      "secondParameter": "",
      "thirdParameter": 0
    }
  },
  "beginPeriodUtcDate": "",
  "catalogCategoryId": "",
  "channelIds": [],
  "endPeriodUtcDate": "",
  "productId": ""
}' |  \
  http POST {{baseUrl}}/v2/user/analytics/:storeId/reports/byday \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "advancedFilters": {\n    "globalMarginPercent": 0,\n    "linkClickToOrderMaxDay": 0,\n    "linkClickToOrderType": "",\n    "marginType": "",\n    "onlyDirectSales": false,\n    "onlyPaymentValidatedOrders": false,\n    "performanceIndicatorFormula": {\n      "firstParameter": "",\n      "operatorName": "",\n      "secondParameter": "",\n      "thirdParameter": 0\n    }\n  },\n  "beginPeriodUtcDate": "",\n  "catalogCategoryId": "",\n  "channelIds": [],\n  "endPeriodUtcDate": "",\n  "productId": ""\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/reports/byday

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "advancedFilters": [
    "globalMarginPercent": 0,
    "linkClickToOrderMaxDay": 0,
    "linkClickToOrderType": "",
    "marginType": "",
    "onlyDirectSales": false,
    "onlyPaymentValidatedOrders": false,
    "performanceIndicatorFormula": [
      "firstParameter": "",
      "operatorName": "",
      "secondParameter": "",
      "thirdParameter": 0
    ]
  ],
  "beginPeriodUtcDate": "",
  "catalogCategoryId": "",
  "channelIds": [],
  "endPeriodUtcDate": "",
  "productId": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/reports/byday")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/reports/byday");

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  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/v2/user/analytics/reports/byday" {:content-type :json
                                                                            :form-params {:advancedFilters {:globalMarginPercent "10"
                                                                                                            :linkClickToOrderMaxDay "5"
                                                                                                            :linkClickToOrderType "OnClickDate"
                                                                                                            :marginType "Global"
                                                                                                            :onlyDirectSales "true"
                                                                                                            :onlyPaymentValidatedOrders "true"
                                                                                                            :performanceIndicatorFormula {:firstParameter "Cost"
                                                                                                                                          :operatorName "Multiply"
                                                                                                                                          :secondParamter "ROI"
                                                                                                                                          :thirdParameter "100"}}
                                                                                          :beginPeriodUtcDate "2006-11-20T00:00:00Z"
                                                                                          :catalogCategoryId "81a058a6-0451-4b79-84ef-94c58d0ed4ac"
                                                                                          :channelIds ["2dc136a7-0d3d-4cc9-a825-a28a42c53e28"]
                                                                                          :endPeriodUtcDate "2006-12-20T00:00:00Z"
                                                                                          :productId "578419df-1bbf-41a6-96fa-862e42182b67"}})

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/reports/byday"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\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}}/v2/user/analytics/reports/byday"),
    Content = new StringContent("{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\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}}/v2/user/analytics/reports/byday");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/v2/user/analytics/reports/byday"

	payload := strings.NewReader("{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\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/v2/user/analytics/reports/byday HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 690

{
  "advancedFilters": {
    "globalMarginPercent": "10",
    "linkClickToOrderMaxDay": "5",
    "linkClickToOrderType": "OnClickDate",
    "marginType": "Global",
    "onlyDirectSales": "true",
    "onlyPaymentValidatedOrders": "true",
    "performanceIndicatorFormula": {
      "firstParameter": "Cost",
      "operatorName": "Multiply",
      "secondParamter": "ROI",
      "thirdParameter": "100"
    }
  },
  "beginPeriodUtcDate": "2006-11-20T00:00:00Z",
  "catalogCategoryId": "81a058a6-0451-4b79-84ef-94c58d0ed4ac",
  "channelIds": [
    "2dc136a7-0d3d-4cc9-a825-a28a42c53e28"
  ],
  "endPeriodUtcDate": "2006-12-20T00:00:00Z",
  "productId": "578419df-1bbf-41a6-96fa-862e42182b67"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/reports/byday")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/reports/byday"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\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  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/reports/byday")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/reports/byday")
  .header("content-type", "application/json")
  .body("{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\n}")
  .asString();

const data = JSON.stringify({
  advancedFilters: {
    globalMarginPercent: '10',
    linkClickToOrderMaxDay: '5',
    linkClickToOrderType: 'OnClickDate',
    marginType: 'Global',
    onlyDirectSales: 'true',
    onlyPaymentValidatedOrders: 'true',
    performanceIndicatorFormula: {
      firstParameter: 'Cost',
      operatorName: 'Multiply',
      secondParamter: 'ROI',
      thirdParameter: '100'
    }
  },
  beginPeriodUtcDate: '2006-11-20T00:00:00Z',
  catalogCategoryId: '81a058a6-0451-4b79-84ef-94c58d0ed4ac',
  channelIds: [
    '2dc136a7-0d3d-4cc9-a825-a28a42c53e28'
  ],
  endPeriodUtcDate: '2006-12-20T00:00:00Z',
  productId: '578419df-1bbf-41a6-96fa-862e42182b67'
});

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

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

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/reports/byday');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/reports/byday',
  headers: {'content-type': 'application/json'},
  data: {
    advancedFilters: {
      globalMarginPercent: '10',
      linkClickToOrderMaxDay: '5',
      linkClickToOrderType: 'OnClickDate',
      marginType: 'Global',
      onlyDirectSales: 'true',
      onlyPaymentValidatedOrders: 'true',
      performanceIndicatorFormula: {
        firstParameter: 'Cost',
        operatorName: 'Multiply',
        secondParamter: 'ROI',
        thirdParameter: '100'
      }
    },
    beginPeriodUtcDate: '2006-11-20T00:00:00Z',
    catalogCategoryId: '81a058a6-0451-4b79-84ef-94c58d0ed4ac',
    channelIds: ['2dc136a7-0d3d-4cc9-a825-a28a42c53e28'],
    endPeriodUtcDate: '2006-12-20T00:00:00Z',
    productId: '578419df-1bbf-41a6-96fa-862e42182b67'
  }
};

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

const url = '{{baseUrl}}/v2/user/analytics/reports/byday';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"advancedFilters":{"globalMarginPercent":"10","linkClickToOrderMaxDay":"5","linkClickToOrderType":"OnClickDate","marginType":"Global","onlyDirectSales":"true","onlyPaymentValidatedOrders":"true","performanceIndicatorFormula":{"firstParameter":"Cost","operatorName":"Multiply","secondParamter":"ROI","thirdParameter":"100"}},"beginPeriodUtcDate":"2006-11-20T00:00:00Z","catalogCategoryId":"81a058a6-0451-4b79-84ef-94c58d0ed4ac","channelIds":["2dc136a7-0d3d-4cc9-a825-a28a42c53e28"],"endPeriodUtcDate":"2006-12-20T00:00:00Z","productId":"578419df-1bbf-41a6-96fa-862e42182b67"}'
};

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}}/v2/user/analytics/reports/byday',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "advancedFilters": {\n    "globalMarginPercent": "10",\n    "linkClickToOrderMaxDay": "5",\n    "linkClickToOrderType": "OnClickDate",\n    "marginType": "Global",\n    "onlyDirectSales": "true",\n    "onlyPaymentValidatedOrders": "true",\n    "performanceIndicatorFormula": {\n      "firstParameter": "Cost",\n      "operatorName": "Multiply",\n      "secondParamter": "ROI",\n      "thirdParameter": "100"\n    }\n  },\n  "beginPeriodUtcDate": "2006-11-20T00:00:00Z",\n  "catalogCategoryId": "81a058a6-0451-4b79-84ef-94c58d0ed4ac",\n  "channelIds": [\n    "2dc136a7-0d3d-4cc9-a825-a28a42c53e28"\n  ],\n  "endPeriodUtcDate": "2006-12-20T00:00:00Z",\n  "productId": "578419df-1bbf-41a6-96fa-862e42182b67"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/reports/byday")
  .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/v2/user/analytics/reports/byday',
  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({
  advancedFilters: {
    globalMarginPercent: '10',
    linkClickToOrderMaxDay: '5',
    linkClickToOrderType: 'OnClickDate',
    marginType: 'Global',
    onlyDirectSales: 'true',
    onlyPaymentValidatedOrders: 'true',
    performanceIndicatorFormula: {
      firstParameter: 'Cost',
      operatorName: 'Multiply',
      secondParamter: 'ROI',
      thirdParameter: '100'
    }
  },
  beginPeriodUtcDate: '2006-11-20T00:00:00Z',
  catalogCategoryId: '81a058a6-0451-4b79-84ef-94c58d0ed4ac',
  channelIds: ['2dc136a7-0d3d-4cc9-a825-a28a42c53e28'],
  endPeriodUtcDate: '2006-12-20T00:00:00Z',
  productId: '578419df-1bbf-41a6-96fa-862e42182b67'
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/reports/byday',
  headers: {'content-type': 'application/json'},
  body: {
    advancedFilters: {
      globalMarginPercent: '10',
      linkClickToOrderMaxDay: '5',
      linkClickToOrderType: 'OnClickDate',
      marginType: 'Global',
      onlyDirectSales: 'true',
      onlyPaymentValidatedOrders: 'true',
      performanceIndicatorFormula: {
        firstParameter: 'Cost',
        operatorName: 'Multiply',
        secondParamter: 'ROI',
        thirdParameter: '100'
      }
    },
    beginPeriodUtcDate: '2006-11-20T00:00:00Z',
    catalogCategoryId: '81a058a6-0451-4b79-84ef-94c58d0ed4ac',
    channelIds: ['2dc136a7-0d3d-4cc9-a825-a28a42c53e28'],
    endPeriodUtcDate: '2006-12-20T00:00:00Z',
    productId: '578419df-1bbf-41a6-96fa-862e42182b67'
  },
  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}}/v2/user/analytics/reports/byday');

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

req.type('json');
req.send({
  advancedFilters: {
    globalMarginPercent: '10',
    linkClickToOrderMaxDay: '5',
    linkClickToOrderType: 'OnClickDate',
    marginType: 'Global',
    onlyDirectSales: 'true',
    onlyPaymentValidatedOrders: 'true',
    performanceIndicatorFormula: {
      firstParameter: 'Cost',
      operatorName: 'Multiply',
      secondParamter: 'ROI',
      thirdParameter: '100'
    }
  },
  beginPeriodUtcDate: '2006-11-20T00:00:00Z',
  catalogCategoryId: '81a058a6-0451-4b79-84ef-94c58d0ed4ac',
  channelIds: [
    '2dc136a7-0d3d-4cc9-a825-a28a42c53e28'
  ],
  endPeriodUtcDate: '2006-12-20T00:00:00Z',
  productId: '578419df-1bbf-41a6-96fa-862e42182b67'
});

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}}/v2/user/analytics/reports/byday',
  headers: {'content-type': 'application/json'},
  data: {
    advancedFilters: {
      globalMarginPercent: '10',
      linkClickToOrderMaxDay: '5',
      linkClickToOrderType: 'OnClickDate',
      marginType: 'Global',
      onlyDirectSales: 'true',
      onlyPaymentValidatedOrders: 'true',
      performanceIndicatorFormula: {
        firstParameter: 'Cost',
        operatorName: 'Multiply',
        secondParamter: 'ROI',
        thirdParameter: '100'
      }
    },
    beginPeriodUtcDate: '2006-11-20T00:00:00Z',
    catalogCategoryId: '81a058a6-0451-4b79-84ef-94c58d0ed4ac',
    channelIds: ['2dc136a7-0d3d-4cc9-a825-a28a42c53e28'],
    endPeriodUtcDate: '2006-12-20T00:00:00Z',
    productId: '578419df-1bbf-41a6-96fa-862e42182b67'
  }
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/analytics/reports/byday';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"advancedFilters":{"globalMarginPercent":"10","linkClickToOrderMaxDay":"5","linkClickToOrderType":"OnClickDate","marginType":"Global","onlyDirectSales":"true","onlyPaymentValidatedOrders":"true","performanceIndicatorFormula":{"firstParameter":"Cost","operatorName":"Multiply","secondParamter":"ROI","thirdParameter":"100"}},"beginPeriodUtcDate":"2006-11-20T00:00:00Z","catalogCategoryId":"81a058a6-0451-4b79-84ef-94c58d0ed4ac","channelIds":["2dc136a7-0d3d-4cc9-a825-a28a42c53e28"],"endPeriodUtcDate":"2006-12-20T00:00:00Z","productId":"578419df-1bbf-41a6-96fa-862e42182b67"}'
};

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 = @{ @"advancedFilters": @{ @"globalMarginPercent": @"10", @"linkClickToOrderMaxDay": @"5", @"linkClickToOrderType": @"OnClickDate", @"marginType": @"Global", @"onlyDirectSales": @"true", @"onlyPaymentValidatedOrders": @"true", @"performanceIndicatorFormula": @{ @"firstParameter": @"Cost", @"operatorName": @"Multiply", @"secondParamter": @"ROI", @"thirdParameter": @"100" } },
                              @"beginPeriodUtcDate": @"2006-11-20T00:00:00Z",
                              @"catalogCategoryId": @"81a058a6-0451-4b79-84ef-94c58d0ed4ac",
                              @"channelIds": @[ @"2dc136a7-0d3d-4cc9-a825-a28a42c53e28" ],
                              @"endPeriodUtcDate": @"2006-12-20T00:00:00Z",
                              @"productId": @"578419df-1bbf-41a6-96fa-862e42182b67" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/reports/byday"]
                                                       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}}/v2/user/analytics/reports/byday" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/analytics/reports/byday",
  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([
    'advancedFilters' => [
        'globalMarginPercent' => '10',
        'linkClickToOrderMaxDay' => '5',
        'linkClickToOrderType' => 'OnClickDate',
        'marginType' => 'Global',
        'onlyDirectSales' => 'true',
        'onlyPaymentValidatedOrders' => 'true',
        'performanceIndicatorFormula' => [
                'firstParameter' => 'Cost',
                'operatorName' => 'Multiply',
                'secondParamter' => 'ROI',
                'thirdParameter' => '100'
        ]
    ],
    'beginPeriodUtcDate' => '2006-11-20T00:00:00Z',
    'catalogCategoryId' => '81a058a6-0451-4b79-84ef-94c58d0ed4ac',
    'channelIds' => [
        '2dc136a7-0d3d-4cc9-a825-a28a42c53e28'
    ],
    'endPeriodUtcDate' => '2006-12-20T00:00:00Z',
    'productId' => '578419df-1bbf-41a6-96fa-862e42182b67'
  ]),
  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}}/v2/user/analytics/reports/byday', [
  'body' => '{
  "advancedFilters": {
    "globalMarginPercent": "10",
    "linkClickToOrderMaxDay": "5",
    "linkClickToOrderType": "OnClickDate",
    "marginType": "Global",
    "onlyDirectSales": "true",
    "onlyPaymentValidatedOrders": "true",
    "performanceIndicatorFormula": {
      "firstParameter": "Cost",
      "operatorName": "Multiply",
      "secondParamter": "ROI",
      "thirdParameter": "100"
    }
  },
  "beginPeriodUtcDate": "2006-11-20T00:00:00Z",
  "catalogCategoryId": "81a058a6-0451-4b79-84ef-94c58d0ed4ac",
  "channelIds": [
    "2dc136a7-0d3d-4cc9-a825-a28a42c53e28"
  ],
  "endPeriodUtcDate": "2006-12-20T00:00:00Z",
  "productId": "578419df-1bbf-41a6-96fa-862e42182b67"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/reports/byday');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'advancedFilters' => [
    'globalMarginPercent' => '10',
    'linkClickToOrderMaxDay' => '5',
    'linkClickToOrderType' => 'OnClickDate',
    'marginType' => 'Global',
    'onlyDirectSales' => 'true',
    'onlyPaymentValidatedOrders' => 'true',
    'performanceIndicatorFormula' => [
        'firstParameter' => 'Cost',
        'operatorName' => 'Multiply',
        'secondParamter' => 'ROI',
        'thirdParameter' => '100'
    ]
  ],
  'beginPeriodUtcDate' => '2006-11-20T00:00:00Z',
  'catalogCategoryId' => '81a058a6-0451-4b79-84ef-94c58d0ed4ac',
  'channelIds' => [
    '2dc136a7-0d3d-4cc9-a825-a28a42c53e28'
  ],
  'endPeriodUtcDate' => '2006-12-20T00:00:00Z',
  'productId' => '578419df-1bbf-41a6-96fa-862e42182b67'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'advancedFilters' => [
    'globalMarginPercent' => '10',
    'linkClickToOrderMaxDay' => '5',
    'linkClickToOrderType' => 'OnClickDate',
    'marginType' => 'Global',
    'onlyDirectSales' => 'true',
    'onlyPaymentValidatedOrders' => 'true',
    'performanceIndicatorFormula' => [
        'firstParameter' => 'Cost',
        'operatorName' => 'Multiply',
        'secondParamter' => 'ROI',
        'thirdParameter' => '100'
    ]
  ],
  'beginPeriodUtcDate' => '2006-11-20T00:00:00Z',
  'catalogCategoryId' => '81a058a6-0451-4b79-84ef-94c58d0ed4ac',
  'channelIds' => [
    '2dc136a7-0d3d-4cc9-a825-a28a42c53e28'
  ],
  'endPeriodUtcDate' => '2006-12-20T00:00:00Z',
  'productId' => '578419df-1bbf-41a6-96fa-862e42182b67'
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/analytics/reports/byday');
$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}}/v2/user/analytics/reports/byday' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "advancedFilters": {
    "globalMarginPercent": "10",
    "linkClickToOrderMaxDay": "5",
    "linkClickToOrderType": "OnClickDate",
    "marginType": "Global",
    "onlyDirectSales": "true",
    "onlyPaymentValidatedOrders": "true",
    "performanceIndicatorFormula": {
      "firstParameter": "Cost",
      "operatorName": "Multiply",
      "secondParamter": "ROI",
      "thirdParameter": "100"
    }
  },
  "beginPeriodUtcDate": "2006-11-20T00:00:00Z",
  "catalogCategoryId": "81a058a6-0451-4b79-84ef-94c58d0ed4ac",
  "channelIds": [
    "2dc136a7-0d3d-4cc9-a825-a28a42c53e28"
  ],
  "endPeriodUtcDate": "2006-12-20T00:00:00Z",
  "productId": "578419df-1bbf-41a6-96fa-862e42182b67"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/reports/byday' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "advancedFilters": {
    "globalMarginPercent": "10",
    "linkClickToOrderMaxDay": "5",
    "linkClickToOrderType": "OnClickDate",
    "marginType": "Global",
    "onlyDirectSales": "true",
    "onlyPaymentValidatedOrders": "true",
    "performanceIndicatorFormula": {
      "firstParameter": "Cost",
      "operatorName": "Multiply",
      "secondParamter": "ROI",
      "thirdParameter": "100"
    }
  },
  "beginPeriodUtcDate": "2006-11-20T00:00:00Z",
  "catalogCategoryId": "81a058a6-0451-4b79-84ef-94c58d0ed4ac",
  "channelIds": [
    "2dc136a7-0d3d-4cc9-a825-a28a42c53e28"
  ],
  "endPeriodUtcDate": "2006-12-20T00:00:00Z",
  "productId": "578419df-1bbf-41a6-96fa-862e42182b67"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/user/analytics/reports/byday", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/analytics/reports/byday"

payload = {
    "advancedFilters": {
        "globalMarginPercent": "10",
        "linkClickToOrderMaxDay": "5",
        "linkClickToOrderType": "OnClickDate",
        "marginType": "Global",
        "onlyDirectSales": "true",
        "onlyPaymentValidatedOrders": "true",
        "performanceIndicatorFormula": {
            "firstParameter": "Cost",
            "operatorName": "Multiply",
            "secondParamter": "ROI",
            "thirdParameter": "100"
        }
    },
    "beginPeriodUtcDate": "2006-11-20T00:00:00Z",
    "catalogCategoryId": "81a058a6-0451-4b79-84ef-94c58d0ed4ac",
    "channelIds": ["2dc136a7-0d3d-4cc9-a825-a28a42c53e28"],
    "endPeriodUtcDate": "2006-12-20T00:00:00Z",
    "productId": "578419df-1bbf-41a6-96fa-862e42182b67"
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/reports/byday"

payload <- "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\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}}/v2/user/analytics/reports/byday")

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  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\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/v2/user/analytics/reports/byday') do |req|
  req.body = "{\n  \"advancedFilters\": {\n    \"globalMarginPercent\": \"10\",\n    \"linkClickToOrderMaxDay\": \"5\",\n    \"linkClickToOrderType\": \"OnClickDate\",\n    \"marginType\": \"Global\",\n    \"onlyDirectSales\": \"true\",\n    \"onlyPaymentValidatedOrders\": \"true\",\n    \"performanceIndicatorFormula\": {\n      \"firstParameter\": \"Cost\",\n      \"operatorName\": \"Multiply\",\n      \"secondParamter\": \"ROI\",\n      \"thirdParameter\": \"100\"\n    }\n  },\n  \"beginPeriodUtcDate\": \"2006-11-20T00:00:00Z\",\n  \"catalogCategoryId\": \"81a058a6-0451-4b79-84ef-94c58d0ed4ac\",\n  \"channelIds\": [\n    \"2dc136a7-0d3d-4cc9-a825-a28a42c53e28\"\n  ],\n  \"endPeriodUtcDate\": \"2006-12-20T00:00:00Z\",\n  \"productId\": \"578419df-1bbf-41a6-96fa-862e42182b67\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/reports/byday";

    let payload = json!({
        "advancedFilters": json!({
            "globalMarginPercent": "10",
            "linkClickToOrderMaxDay": "5",
            "linkClickToOrderType": "OnClickDate",
            "marginType": "Global",
            "onlyDirectSales": "true",
            "onlyPaymentValidatedOrders": "true",
            "performanceIndicatorFormula": json!({
                "firstParameter": "Cost",
                "operatorName": "Multiply",
                "secondParamter": "ROI",
                "thirdParameter": "100"
            })
        }),
        "beginPeriodUtcDate": "2006-11-20T00:00:00Z",
        "catalogCategoryId": "81a058a6-0451-4b79-84ef-94c58d0ed4ac",
        "channelIds": ("2dc136a7-0d3d-4cc9-a825-a28a42c53e28"),
        "endPeriodUtcDate": "2006-12-20T00:00:00Z",
        "productId": "578419df-1bbf-41a6-96fa-862e42182b67"
    });

    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);
}

echo '{
  "advancedFilters": {
    "globalMarginPercent": "10",
    "linkClickToOrderMaxDay": "5",
    "linkClickToOrderType": "OnClickDate",
    "marginType": "Global",
    "onlyDirectSales": "true",
    "onlyPaymentValidatedOrders": "true",
    "performanceIndicatorFormula": {
      "firstParameter": "Cost",
      "operatorName": "Multiply",
      "secondParamter": "ROI",
      "thirdParameter": "100"
    }
  },
  "beginPeriodUtcDate": "2006-11-20T00:00:00Z",
  "catalogCategoryId": "81a058a6-0451-4b79-84ef-94c58d0ed4ac",
  "channelIds": [
    "2dc136a7-0d3d-4cc9-a825-a28a42c53e28"
  ],
  "endPeriodUtcDate": "2006-12-20T00:00:00Z",
  "productId": "578419df-1bbf-41a6-96fa-862e42182b67"
}' |  \
  http POST {{baseUrl}}/v2/user/analytics/reports/byday \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "advancedFilters": {\n    "globalMarginPercent": "10",\n    "linkClickToOrderMaxDay": "5",\n    "linkClickToOrderType": "OnClickDate",\n    "marginType": "Global",\n    "onlyDirectSales": "true",\n    "onlyPaymentValidatedOrders": "true",\n    "performanceIndicatorFormula": {\n      "firstParameter": "Cost",\n      "operatorName": "Multiply",\n      "secondParamter": "ROI",\n      "thirdParameter": "100"\n    }\n  },\n  "beginPeriodUtcDate": "2006-11-20T00:00:00Z",\n  "catalogCategoryId": "81a058a6-0451-4b79-84ef-94c58d0ed4ac",\n  "channelIds": [\n    "2dc136a7-0d3d-4cc9-a825-a28a42c53e28"\n  ],\n  "endPeriodUtcDate": "2006-12-20T00:00:00Z",\n  "productId": "578419df-1bbf-41a6-96fa-862e42182b67"\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/reports/byday

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "advancedFilters": [
    "globalMarginPercent": "10",
    "linkClickToOrderMaxDay": "5",
    "linkClickToOrderType": "OnClickDate",
    "marginType": "Global",
    "onlyDirectSales": "true",
    "onlyPaymentValidatedOrders": "true",
    "performanceIndicatorFormula": [
      "firstParameter": "Cost",
      "operatorName": "Multiply",
      "secondParamter": "ROI",
      "thirdParameter": "100"
    ]
  ],
  "beginPeriodUtcDate": "2006-11-20T00:00:00Z",
  "catalogCategoryId": "81a058a6-0451-4b79-84ef-94c58d0ed4ac",
  "channelIds": ["2dc136a7-0d3d-4cc9-a825-a28a42c53e28"],
  "endPeriodUtcDate": "2006-12-20T00:00:00Z",
  "productId": "578419df-1bbf-41a6-96fa-862e42182b67"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/reports/byday")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/user/analytics/:storeId/reports/byproduct HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/reports/byproduct',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct');

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}}/v2/user/analytics/:storeId/reports/byproduct'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = ""

conn.request("POST", "/baseUrl/v2/user/analytics/:storeId/reports/byproduct", payload)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct"

payload = ""

response = requests.post(url, data=payload)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct"

payload <- ""

response <- VERB("POST", url, body = payload, content_type(""))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v2/user/analytics/:storeId/reports/byproduct') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/reports/byproduct")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/tracking/status");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/user/analytics/tracking/status")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/tracking/status"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/tracking/status"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/tracking/status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/analytics/tracking/status"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/user/analytics/tracking/status HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/analytics/tracking/status")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/tracking/status"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/tracking/status")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/analytics/tracking/status")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/user/analytics/tracking/status');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/tracking/status'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/analytics/tracking/status';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/tracking/status',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/tracking/status")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/tracking/status',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/tracking/status'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/tracking/status');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/tracking/status'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/analytics/tracking/status';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/tracking/status"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/tracking/status" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/analytics/tracking/status",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/user/analytics/tracking/status');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/tracking/status');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/analytics/tracking/status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/tracking/status' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/tracking/status' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/user/analytics/tracking/status")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/analytics/tracking/status"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/tracking/status"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/tracking/status")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/user/analytics/tracking/status') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/tracking/status";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/analytics/tracking/status

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/tracking/status

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/tracking/status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks"

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}}/v2/user/analytics/:storeId/tracking/clicks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks"

	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/v2/user/analytics/:storeId/tracking/clicks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks"))
    .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}}/v2/user/analytics/:storeId/tracking/clicks")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks")
  .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}}/v2/user/analytics/:storeId/tracking/clicks');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks';
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}}/v2/user/analytics/:storeId/tracking/clicks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/tracking/clicks',
  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}}/v2/user/analytics/:storeId/tracking/clicks'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks');

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}}/v2/user/analytics/:storeId/tracking/clicks'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks';
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}}/v2/user/analytics/:storeId/tracking/clicks"]
                                                       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}}/v2/user/analytics/:storeId/tracking/clicks" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks",
  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}}/v2/user/analytics/:storeId/tracking/clicks');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/user/analytics/:storeId/tracking/clicks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks")

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/v2/user/analytics/:storeId/tracking/clicks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/tracking/clicks")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders"

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}}/v2/user/analytics/:storeId/tracking/externalorders"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders"

	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/v2/user/analytics/:storeId/tracking/externalorders HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders"))
    .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}}/v2/user/analytics/:storeId/tracking/externalorders")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders")
  .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}}/v2/user/analytics/:storeId/tracking/externalorders');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders';
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}}/v2/user/analytics/:storeId/tracking/externalorders',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/tracking/externalorders',
  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}}/v2/user/analytics/:storeId/tracking/externalorders'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders');

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}}/v2/user/analytics/:storeId/tracking/externalorders'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders';
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}}/v2/user/analytics/:storeId/tracking/externalorders"]
                                                       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}}/v2/user/analytics/:storeId/tracking/externalorders" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders",
  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}}/v2/user/analytics/:storeId/tracking/externalorders');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/user/analytics/:storeId/tracking/externalorders")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders")

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/v2/user/analytics/:storeId/tracking/externalorders') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/tracking/externalorders")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders"

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}}/v2/user/analytics/:storeId/tracking/orders"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders"

	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/v2/user/analytics/:storeId/tracking/orders HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders"))
    .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}}/v2/user/analytics/:storeId/tracking/orders")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders")
  .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}}/v2/user/analytics/:storeId/tracking/orders');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders';
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}}/v2/user/analytics/:storeId/tracking/orders',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/tracking/orders',
  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}}/v2/user/analytics/:storeId/tracking/orders'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders');

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}}/v2/user/analytics/:storeId/tracking/orders'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders';
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}}/v2/user/analytics/:storeId/tracking/orders"]
                                                       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}}/v2/user/analytics/:storeId/tracking/orders" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders",
  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}}/v2/user/analytics/:storeId/tracking/orders');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/user/analytics/:storeId/tracking/orders")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders")

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/v2/user/analytics/:storeId/tracking/orders') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/analytics/:storeId/tracking/orders

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/tracking/orders

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/tracking/orders")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/analytics/:storeId/tracking/status");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/user/analytics/:storeId/tracking/status")

require "http/client"

url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/status"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/user/analytics/:storeId/tracking/status"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/analytics/:storeId/tracking/status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/analytics/:storeId/tracking/status"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/user/analytics/:storeId/tracking/status HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/analytics/:storeId/tracking/status")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/analytics/:storeId/tracking/status"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/tracking/status")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/analytics/:storeId/tracking/status")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v2/user/analytics/:storeId/tracking/status');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/tracking/status'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/analytics/:storeId/tracking/status';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/analytics/:storeId/tracking/status',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/analytics/:storeId/tracking/status")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/analytics/:storeId/tracking/status',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/tracking/status'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/analytics/:storeId/tracking/status');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/analytics/:storeId/tracking/status'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/analytics/:storeId/tracking/status';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/analytics/:storeId/tracking/status"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/analytics/:storeId/tracking/status" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/analytics/:storeId/tracking/status",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/user/analytics/:storeId/tracking/status');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/analytics/:storeId/tracking/status');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/analytics/:storeId/tracking/status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/analytics/:storeId/tracking/status' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/analytics/:storeId/tracking/status' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/user/analytics/:storeId/tracking/status")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/status"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/analytics/:storeId/tracking/status"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/analytics/:storeId/tracking/status")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/user/analytics/:storeId/tracking/status') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/analytics/:storeId/tracking/status";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/analytics/:storeId/tracking/status

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/analytics/:storeId/tracking/status

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/analytics/:storeId/tracking/status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate")

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/user/catalogs/:storeId/autoImport/activate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/autoImport/activate',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate');

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}}/v2/user/catalogs/:storeId/autoImport/activate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v2/user/catalogs/:storeId/autoImport/activate")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v2/user/catalogs/:storeId/autoImport/activate') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/activate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval");

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  \"interval\": \"04:00:00\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval" {:content-type :json
                                                                                                     :form-params {:interval "04:00:00"}})

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"interval\": \"04:00:00\"\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}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval"),
    Content = new StringContent("{\n  \"interval\": \"04:00:00\"\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}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"interval\": \"04:00:00\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval"

	payload := strings.NewReader("{\n  \"interval\": \"04:00:00\"\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/v2/user/catalogs/:storeId/autoImport/scheduling/interval HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "interval": "04:00:00"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"interval\": \"04:00:00\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"interval\": \"04:00:00\"\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  \"interval\": \"04:00:00\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval")
  .header("content-type", "application/json")
  .body("{\n  \"interval\": \"04:00:00\"\n}")
  .asString();

const data = JSON.stringify({
  interval: '04:00:00'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval',
  headers: {'content-type': 'application/json'},
  data: {interval: '04:00:00'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"interval":"04:00:00"}'
};

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}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "interval": "04:00:00"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"interval\": \"04:00:00\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval")
  .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/v2/user/catalogs/:storeId/autoImport/scheduling/interval',
  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({interval: '04:00:00'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval',
  headers: {'content-type': 'application/json'},
  body: {interval: '04:00:00'},
  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}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  interval: '04:00:00'
});

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}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval',
  headers: {'content-type': 'application/json'},
  data: {interval: '04:00:00'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"interval":"04:00:00"}'
};

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 = @{ @"interval": @"04:00:00" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval"]
                                                       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}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"interval\": \"04:00:00\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval",
  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([
    'interval' => '04:00:00'
  ]),
  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}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval', [
  'body' => '{
  "interval": "04:00:00"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'interval' => '04:00:00'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'interval' => '04:00:00'
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval');
$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}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "interval": "04:00:00"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "interval": "04:00:00"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"interval\": \"04:00:00\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/user/catalogs/:storeId/autoImport/scheduling/interval", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval"

payload = { "interval": "04:00:00" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval"

payload <- "{\n  \"interval\": \"04:00:00\"\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}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval")

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  \"interval\": \"04:00:00\"\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/v2/user/catalogs/:storeId/autoImport/scheduling/interval') do |req|
  req.body = "{\n  \"interval\": \"04:00:00\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval";

    let payload = json!({"interval": "04:00:00"});

    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);
}

echo '{
  "interval": "04:00:00"
}' |  \
  http POST {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "interval": "04:00:00"\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["interval": "04:00:00"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/interval")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules");

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  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules" {:content-type :json
                                                                                                      :form-params {:localTimeZoneName "Romance Standard Time"
                                                                                                                    :schedules ["21:00:00" "23:00:00" "08:30:00"]}})

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\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}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules"),
    Content = new StringContent("{\n  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\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}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules"

	payload := strings.NewReader("{\n  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\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/v2/user/catalogs/:storeId/autoImport/scheduling/schedules HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 119

{
  "localTimeZoneName": "Romance Standard Time",
  "schedules": [
    "21:00:00",
    "23:00:00",
    "08:30:00"
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\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  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules")
  .header("content-type", "application/json")
  .body("{\n  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\n  ]\n}")
  .asString();

const data = JSON.stringify({
  localTimeZoneName: 'Romance Standard Time',
  schedules: [
    '21:00:00',
    '23:00:00',
    '08:30:00'
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules',
  headers: {'content-type': 'application/json'},
  data: {
    localTimeZoneName: 'Romance Standard Time',
    schedules: ['21:00:00', '23:00:00', '08:30:00']
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"localTimeZoneName":"Romance Standard Time","schedules":["21:00:00","23:00:00","08:30:00"]}'
};

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}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "localTimeZoneName": "Romance Standard Time",\n  "schedules": [\n    "21:00:00",\n    "23:00:00",\n    "08:30:00"\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  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules")
  .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/v2/user/catalogs/:storeId/autoImport/scheduling/schedules',
  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({
  localTimeZoneName: 'Romance Standard Time',
  schedules: ['21:00:00', '23:00:00', '08:30:00']
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules',
  headers: {'content-type': 'application/json'},
  body: {
    localTimeZoneName: 'Romance Standard Time',
    schedules: ['21:00:00', '23:00:00', '08:30:00']
  },
  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}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  localTimeZoneName: 'Romance Standard Time',
  schedules: [
    '21:00:00',
    '23:00:00',
    '08:30:00'
  ]
});

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}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules',
  headers: {'content-type': 'application/json'},
  data: {
    localTimeZoneName: 'Romance Standard Time',
    schedules: ['21:00:00', '23:00:00', '08:30:00']
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"localTimeZoneName":"Romance Standard Time","schedules":["21:00:00","23:00:00","08:30:00"]}'
};

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 = @{ @"localTimeZoneName": @"Romance Standard Time",
                              @"schedules": @[ @"21:00:00", @"23:00:00", @"08:30:00" ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules"]
                                                       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}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules",
  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([
    'localTimeZoneName' => 'Romance Standard Time',
    'schedules' => [
        '21:00:00',
        '23:00:00',
        '08:30:00'
    ]
  ]),
  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}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules', [
  'body' => '{
  "localTimeZoneName": "Romance Standard Time",
  "schedules": [
    "21:00:00",
    "23:00:00",
    "08:30:00"
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'localTimeZoneName' => 'Romance Standard Time',
  'schedules' => [
    '21:00:00',
    '23:00:00',
    '08:30:00'
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'localTimeZoneName' => 'Romance Standard Time',
  'schedules' => [
    '21:00:00',
    '23:00:00',
    '08:30:00'
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules');
$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}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "localTimeZoneName": "Romance Standard Time",
  "schedules": [
    "21:00:00",
    "23:00:00",
    "08:30:00"
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "localTimeZoneName": "Romance Standard Time",
  "schedules": [
    "21:00:00",
    "23:00:00",
    "08:30:00"
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/user/catalogs/:storeId/autoImport/scheduling/schedules", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules"

payload = {
    "localTimeZoneName": "Romance Standard Time",
    "schedules": ["21:00:00", "23:00:00", "08:30:00"]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules"

payload <- "{\n  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\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}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules")

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  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\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/v2/user/catalogs/:storeId/autoImport/scheduling/schedules') do |req|
  req.body = "{\n  \"localTimeZoneName\": \"Romance Standard Time\",\n  \"schedules\": [\n    \"21:00:00\",\n    \"23:00:00\",\n    \"08:30:00\"\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules";

    let payload = json!({
        "localTimeZoneName": "Romance Standard Time",
        "schedules": ("21:00:00", "23:00:00", "08:30:00")
    });

    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);
}

echo '{
  "localTimeZoneName": "Romance Standard Time",
  "schedules": [
    "21:00:00",
    "23:00:00",
    "08:30:00"
  ]
}' |  \
  http POST {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "localTimeZoneName": "Romance Standard Time",\n  "schedules": [\n    "21:00:00",\n    "23:00:00",\n    "08:30:00"\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "localTimeZoneName": "Romance Standard Time",
  "schedules": ["21:00:00", "23:00:00", "08:30:00"]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/scheduling/schedules")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport"

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}}/v2/user/catalogs/:storeId/autoImport"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport"

	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/v2/user/catalogs/:storeId/autoImport HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport"))
    .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}}/v2/user/catalogs/:storeId/autoImport")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")
  .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}}/v2/user/catalogs/:storeId/autoImport');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport';
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}}/v2/user/catalogs/:storeId/autoImport',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/autoImport',
  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}}/v2/user/catalogs/:storeId/autoImport'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport');

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}}/v2/user/catalogs/:storeId/autoImport'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport';
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}}/v2/user/catalogs/:storeId/autoImport"]
                                                       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}}/v2/user/catalogs/:storeId/autoImport" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport",
  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}}/v2/user/catalogs/:storeId/autoImport');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v2/user/catalogs/:storeId/autoImport")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")

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/v2/user/catalogs/:storeId/autoImport') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport";

    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);
}

http DELETE {{baseUrl}}/v2/user/catalogs/:storeId/autoImport

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/autoImport

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport"

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}}/v2/user/catalogs/:storeId/autoImport"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport"

	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/v2/user/catalogs/:storeId/autoImport HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport"))
    .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}}/v2/user/catalogs/:storeId/autoImport")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")
  .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}}/v2/user/catalogs/:storeId/autoImport');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport';
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}}/v2/user/catalogs/:storeId/autoImport',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/autoImport',
  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}}/v2/user/catalogs/:storeId/autoImport'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport');

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}}/v2/user/catalogs/:storeId/autoImport'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport';
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}}/v2/user/catalogs/:storeId/autoImport"]
                                                       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}}/v2/user/catalogs/:storeId/autoImport" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport",
  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}}/v2/user/catalogs/:storeId/autoImport');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/user/catalogs/:storeId/autoImport")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")

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/v2/user/catalogs/:storeId/autoImport') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/catalogs/:storeId/autoImport

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/autoImport

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause")

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/user/catalogs/:storeId/autoImport/pause HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/autoImport/pause',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause');

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}}/v2/user/catalogs/:storeId/autoImport/pause'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v2/user/catalogs/:storeId/autoImport/pause")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v2/user/catalogs/:storeId/autoImport/pause') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/pause")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume")

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/user/catalogs/:storeId/autoImport/resume HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/autoImport/resume',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume');

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}}/v2/user/catalogs/:storeId/autoImport/resume'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v2/user/catalogs/:storeId/autoImport/resume")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v2/user/catalogs/:storeId/autoImport/resume') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/resume")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start")

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v2/user/catalogs/:storeId/autoImport/start HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/autoImport/start',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start');

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}}/v2/user/catalogs/:storeId/autoImport/start'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/v2/user/catalogs/:storeId/autoImport/start")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/v2/user/catalogs/:storeId/autoImport/start') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/autoImport/start")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename");

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  \"userColumName\": \"My SKU\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename" {:content-type :json
                                                                                                      :form-params {:userColumName "My SKU"}})

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"userColumName\": \"My SKU\"\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}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename"),
    Content = new StringContent("{\n  \"userColumName\": \"My SKU\"\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}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"userColumName\": \"My SKU\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename"

	payload := strings.NewReader("{\n  \"userColumName\": \"My SKU\"\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/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 31

{
  "userColumName": "My SKU"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"userColumName\": \"My SKU\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"userColumName\": \"My SKU\"\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  \"userColumName\": \"My SKU\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename")
  .header("content-type", "application/json")
  .body("{\n  \"userColumName\": \"My SKU\"\n}")
  .asString();

const data = JSON.stringify({
  userColumName: 'My SKU'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename',
  headers: {'content-type': 'application/json'},
  data: {userColumName: 'My SKU'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"userColumName":"My SKU"}'
};

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}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "userColumName": "My SKU"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"userColumName\": \"My SKU\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename")
  .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/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename',
  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({userColumName: 'My SKU'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename',
  headers: {'content-type': 'application/json'},
  body: {userColumName: 'My SKU'},
  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}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  userColumName: 'My SKU'
});

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}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename',
  headers: {'content-type': 'application/json'},
  data: {userColumName: 'My SKU'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"userColumName":"My SKU"}'
};

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 = @{ @"userColumName": @"My SKU" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename"]
                                                       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}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"userColumName\": \"My SKU\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename",
  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([
    'userColumName' => 'My SKU'
  ]),
  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}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename', [
  'body' => '{
  "userColumName": "My SKU"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'userColumName' => 'My SKU'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'userColumName' => 'My SKU'
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename');
$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}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "userColumName": "My SKU"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "userColumName": "My SKU"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"userColumName\": \"My SKU\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename"

payload = { "userColumName": "My SKU" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename"

payload <- "{\n  \"userColumName\": \"My SKU\"\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}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename")

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  \"userColumName\": \"My SKU\"\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/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename') do |req|
  req.body = "{\n  \"userColumName\": \"My SKU\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename";

    let payload = json!({"userColumName": "My SKU"});

    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);
}

echo '{
  "userColumName": "My SKU"
}' |  \
  http POST {{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "userColumName": "My SKU"\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["userColumName": "My SKU"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns/:columnId/rename")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename");

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  \"userColumName\": \"My SKU\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename" {:content-type :json
                                                                                                     :form-params {:userColumName "My SKU"}})

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"userColumName\": \"My SKU\"\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}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename"),
    Content = new StringContent("{\n  \"userColumName\": \"My SKU\"\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}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"userColumName\": \"My SKU\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename"

	payload := strings.NewReader("{\n  \"userColumName\": \"My SKU\"\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/v2/user/catalogs/:storeId/customColumns/:columnId/rename HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 31

{
  "userColumName": "My SKU"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"userColumName\": \"My SKU\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"userColumName\": \"My SKU\"\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  \"userColumName\": \"My SKU\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename")
  .header("content-type", "application/json")
  .body("{\n  \"userColumName\": \"My SKU\"\n}")
  .asString();

const data = JSON.stringify({
  userColumName: 'My SKU'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename',
  headers: {'content-type': 'application/json'},
  data: {userColumName: 'My SKU'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"userColumName":"My SKU"}'
};

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}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "userColumName": "My SKU"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"userColumName\": \"My SKU\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename")
  .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/v2/user/catalogs/:storeId/customColumns/:columnId/rename',
  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({userColumName: 'My SKU'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename',
  headers: {'content-type': 'application/json'},
  body: {userColumName: 'My SKU'},
  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}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  userColumName: 'My SKU'
});

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}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename',
  headers: {'content-type': 'application/json'},
  data: {userColumName: 'My SKU'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"userColumName":"My SKU"}'
};

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 = @{ @"userColumName": @"My SKU" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename"]
                                                       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}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"userColumName\": \"My SKU\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename",
  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([
    'userColumName' => 'My SKU'
  ]),
  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}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename', [
  'body' => '{
  "userColumName": "My SKU"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'userColumName' => 'My SKU'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'userColumName' => 'My SKU'
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename');
$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}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "userColumName": "My SKU"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "userColumName": "My SKU"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"userColumName\": \"My SKU\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/user/catalogs/:storeId/customColumns/:columnId/rename", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename"

payload = { "userColumName": "My SKU" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename"

payload <- "{\n  \"userColumName\": \"My SKU\"\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}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename")

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  \"userColumName\": \"My SKU\"\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/v2/user/catalogs/:storeId/customColumns/:columnId/rename') do |req|
  req.body = "{\n  \"userColumName\": \"My SKU\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename";

    let payload = json!({"userColumName": "My SKU"});

    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);
}

echo '{
  "userColumName": "My SKU"
}' |  \
  http POST {{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "userColumName": "My SKU"\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["userColumName": "My SKU"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/rename")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression");

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  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression" {:content-type :json
                                                                                                        :form-params {:encryptedBlocklyExpression "apokpoa,opz,sixsoisiosnoisn"
                                                                                                                      :encryptedExpression "uziushdczaniodnndonisodndsiondsoidsndoin"}})

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression"),
    Content = new StringContent("{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\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}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression"

	payload := strings.NewReader("{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/user/catalogs/:storeId/customColumns/:columnId/expression HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 134

{
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\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  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression")
  .header("content-type", "application/json")
  .body("{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}")
  .asString();

const data = JSON.stringify({
  encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
  encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression',
  headers: {'content-type': 'application/json'},
  data: {
    encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
    encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"encryptedBlocklyExpression":"apokpoa,opz,sixsoisiosnoisn","encryptedExpression":"uziushdczaniodnndonisodndsiondsoidsndoin"}'
};

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}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",\n  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/customColumns/:columnId/expression',
  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({
  encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
  encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin'
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression',
  headers: {'content-type': 'application/json'},
  body: {
    encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
    encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
  encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression',
  headers: {'content-type': 'application/json'},
  data: {
    encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
    encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"encryptedBlocklyExpression":"apokpoa,opz,sixsoisiosnoisn","encryptedExpression":"uziushdczaniodnndonisodndsiondsoidsndoin"}'
};

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 = @{ @"encryptedBlocklyExpression": @"apokpoa,opz,sixsoisiosnoisn",
                              @"encryptedExpression": @"uziushdczaniodnndonisodndsiondsoidsndoin" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'encryptedBlocklyExpression' => 'apokpoa,opz,sixsoisiosnoisn',
    'encryptedExpression' => 'uziushdczaniodnndonisodndsiondsoidsndoin'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression', [
  'body' => '{
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'encryptedBlocklyExpression' => 'apokpoa,opz,sixsoisiosnoisn',
  'encryptedExpression' => 'uziushdczaniodnndonisodndsiondsoidsndoin'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'encryptedBlocklyExpression' => 'apokpoa,opz,sixsoisiosnoisn',
  'encryptedExpression' => 'uziushdczaniodnndonisodndsiondsoidsndoin'
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v2/user/catalogs/:storeId/customColumns/:columnId/expression", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression"

payload = {
    "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
    "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin"
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression"

payload <- "{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/v2/user/catalogs/:storeId/customColumns/:columnId/expression') do |req|
  req.body = "{\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\"\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}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression";

    let payload = json!({
        "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
        "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin"
}' |  \
  http PUT {{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",\n  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin"\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId/expression")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression");

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  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression" {:content-type :json
                                                                                                      :form-params {:encryptedExpression "uziushdczaniodnndonisodndsiondsoidsndoin"
                                                                                                                    :productValues {:012929c0-e78b-462a-a96e-25c061575385 "http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg"
                                                                                                                                    :46602e10-bc45-4944-a440-63d5f7ece1f8 "42"
                                                                                                                                    :68082b11-4ffd-4bec-964a-465a471c7d37 "SKU1234"
                                                                                                                                    :b6d74510-41ce-42ec-947a-0bdf62e9beee "Refrigerateur"
                                                                                                                                    :ba270fa0-8482-46be-905a-cae4ca746b92 "http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"}}})

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\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}}/v2/user/catalogs/:storeId/customColumns/computeExpression"),
    Content = new StringContent("{\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\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}}/v2/user/catalogs/:storeId/customColumns/computeExpression");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression"

	payload := strings.NewReader("{\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\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/v2/user/catalogs/:storeId/customColumns/computeExpression HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 564

{
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "productValues": {
    "012929c0-e78b-462a-a96e-25c061575385": "http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg",
    "46602e10-bc45-4944-a440-63d5f7ece1f8": "42",
    "68082b11-4ffd-4bec-964a-465a471c7d37": "SKU1234",
    "b6d74510-41ce-42ec-947a-0bdf62e9beee": "Refrigerateur",
    "ba270fa0-8482-46be-905a-cae4ca746b92": "http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\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  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression")
  .header("content-type", "application/json")
  .body("{\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
  productValues: {
    '012929c0-e78b-462a-a96e-25c061575385': 'http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg',
    '46602e10-bc45-4944-a440-63d5f7ece1f8': '42',
    '68082b11-4ffd-4bec-964a-465a471c7d37': 'SKU1234',
    'b6d74510-41ce-42ec-947a-0bdf62e9beee': 'Refrigerateur',
    'ba270fa0-8482-46be-905a-cae4ca746b92': 'http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511'
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression',
  headers: {'content-type': 'application/json'},
  data: {
    encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
    productValues: {
      '012929c0-e78b-462a-a96e-25c061575385': 'http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg',
      '46602e10-bc45-4944-a440-63d5f7ece1f8': '42',
      '68082b11-4ffd-4bec-964a-465a471c7d37': 'SKU1234',
      'b6d74510-41ce-42ec-947a-0bdf62e9beee': 'Refrigerateur',
      'ba270fa0-8482-46be-905a-cae4ca746b92': 'http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511'
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"encryptedExpression":"uziushdczaniodnndonisodndsiondsoidsndoin","productValues":{"012929c0-e78b-462a-a96e-25c061575385":"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg","46602e10-bc45-4944-a440-63d5f7ece1f8":"42","68082b11-4ffd-4bec-964a-465a471c7d37":"SKU1234","b6d74510-41ce-42ec-947a-0bdf62e9beee":"Refrigerateur","ba270fa0-8482-46be-905a-cae4ca746b92":"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"}}'
};

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}}/v2/user/catalogs/:storeId/customColumns/computeExpression',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",\n  "productValues": {\n    "012929c0-e78b-462a-a96e-25c061575385": "http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg",\n    "46602e10-bc45-4944-a440-63d5f7ece1f8": "42",\n    "68082b11-4ffd-4bec-964a-465a471c7d37": "SKU1234",\n    "b6d74510-41ce-42ec-947a-0bdf62e9beee": "Refrigerateur",\n    "ba270fa0-8482-46be-905a-cae4ca746b92": "http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"\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  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression")
  .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/v2/user/catalogs/:storeId/customColumns/computeExpression',
  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({
  encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
  productValues: {
    '012929c0-e78b-462a-a96e-25c061575385': 'http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg',
    '46602e10-bc45-4944-a440-63d5f7ece1f8': '42',
    '68082b11-4ffd-4bec-964a-465a471c7d37': 'SKU1234',
    'b6d74510-41ce-42ec-947a-0bdf62e9beee': 'Refrigerateur',
    'ba270fa0-8482-46be-905a-cae4ca746b92': 'http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511'
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression',
  headers: {'content-type': 'application/json'},
  body: {
    encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
    productValues: {
      '012929c0-e78b-462a-a96e-25c061575385': 'http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg',
      '46602e10-bc45-4944-a440-63d5f7ece1f8': '42',
      '68082b11-4ffd-4bec-964a-465a471c7d37': 'SKU1234',
      'b6d74510-41ce-42ec-947a-0bdf62e9beee': 'Refrigerateur',
      'ba270fa0-8482-46be-905a-cae4ca746b92': 'http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511'
    }
  },
  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}}/v2/user/catalogs/:storeId/customColumns/computeExpression');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
  productValues: {
    '012929c0-e78b-462a-a96e-25c061575385': 'http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg',
    '46602e10-bc45-4944-a440-63d5f7ece1f8': '42',
    '68082b11-4ffd-4bec-964a-465a471c7d37': 'SKU1234',
    'b6d74510-41ce-42ec-947a-0bdf62e9beee': 'Refrigerateur',
    'ba270fa0-8482-46be-905a-cae4ca746b92': 'http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511'
  }
});

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}}/v2/user/catalogs/:storeId/customColumns/computeExpression',
  headers: {'content-type': 'application/json'},
  data: {
    encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
    productValues: {
      '012929c0-e78b-462a-a96e-25c061575385': 'http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg',
      '46602e10-bc45-4944-a440-63d5f7ece1f8': '42',
      '68082b11-4ffd-4bec-964a-465a471c7d37': 'SKU1234',
      'b6d74510-41ce-42ec-947a-0bdf62e9beee': 'Refrigerateur',
      'ba270fa0-8482-46be-905a-cae4ca746b92': 'http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511'
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"encryptedExpression":"uziushdczaniodnndonisodndsiondsoidsndoin","productValues":{"012929c0-e78b-462a-a96e-25c061575385":"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg","46602e10-bc45-4944-a440-63d5f7ece1f8":"42","68082b11-4ffd-4bec-964a-465a471c7d37":"SKU1234","b6d74510-41ce-42ec-947a-0bdf62e9beee":"Refrigerateur","ba270fa0-8482-46be-905a-cae4ca746b92":"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"}}'
};

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 = @{ @"encryptedExpression": @"uziushdczaniodnndonisodndsiondsoidsndoin",
                              @"productValues": @{ @"012929c0-e78b-462a-a96e-25c061575385": @"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg", @"46602e10-bc45-4944-a440-63d5f7ece1f8": @"42", @"68082b11-4ffd-4bec-964a-465a471c7d37": @"SKU1234", @"b6d74510-41ce-42ec-947a-0bdf62e9beee": @"Refrigerateur", @"ba270fa0-8482-46be-905a-cae4ca746b92": @"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression"]
                                                       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}}/v2/user/catalogs/:storeId/customColumns/computeExpression" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression",
  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([
    'encryptedExpression' => 'uziushdczaniodnndonisodndsiondsoidsndoin',
    'productValues' => [
        '012929c0-e78b-462a-a96e-25c061575385' => 'http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg',
        '46602e10-bc45-4944-a440-63d5f7ece1f8' => '42',
        '68082b11-4ffd-4bec-964a-465a471c7d37' => 'SKU1234',
        'b6d74510-41ce-42ec-947a-0bdf62e9beee' => 'Refrigerateur',
        'ba270fa0-8482-46be-905a-cae4ca746b92' => 'http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511'
    ]
  ]),
  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}}/v2/user/catalogs/:storeId/customColumns/computeExpression', [
  'body' => '{
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "productValues": {
    "012929c0-e78b-462a-a96e-25c061575385": "http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg",
    "46602e10-bc45-4944-a440-63d5f7ece1f8": "42",
    "68082b11-4ffd-4bec-964a-465a471c7d37": "SKU1234",
    "b6d74510-41ce-42ec-947a-0bdf62e9beee": "Refrigerateur",
    "ba270fa0-8482-46be-905a-cae4ca746b92": "http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'encryptedExpression' => 'uziushdczaniodnndonisodndsiondsoidsndoin',
  'productValues' => [
    '012929c0-e78b-462a-a96e-25c061575385' => 'http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg',
    '46602e10-bc45-4944-a440-63d5f7ece1f8' => '42',
    '68082b11-4ffd-4bec-964a-465a471c7d37' => 'SKU1234',
    'b6d74510-41ce-42ec-947a-0bdf62e9beee' => 'Refrigerateur',
    'ba270fa0-8482-46be-905a-cae4ca746b92' => 'http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511'
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'encryptedExpression' => 'uziushdczaniodnndonisodndsiondsoidsndoin',
  'productValues' => [
    '012929c0-e78b-462a-a96e-25c061575385' => 'http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg',
    '46602e10-bc45-4944-a440-63d5f7ece1f8' => '42',
    '68082b11-4ffd-4bec-964a-465a471c7d37' => 'SKU1234',
    'b6d74510-41ce-42ec-947a-0bdf62e9beee' => 'Refrigerateur',
    'ba270fa0-8482-46be-905a-cae4ca746b92' => 'http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511'
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression');
$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}}/v2/user/catalogs/:storeId/customColumns/computeExpression' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "productValues": {
    "012929c0-e78b-462a-a96e-25c061575385": "http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg",
    "46602e10-bc45-4944-a440-63d5f7ece1f8": "42",
    "68082b11-4ffd-4bec-964a-465a471c7d37": "SKU1234",
    "b6d74510-41ce-42ec-947a-0bdf62e9beee": "Refrigerateur",
    "ba270fa0-8482-46be-905a-cae4ca746b92": "http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "productValues": {
    "012929c0-e78b-462a-a96e-25c061575385": "http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg",
    "46602e10-bc45-4944-a440-63d5f7ece1f8": "42",
    "68082b11-4ffd-4bec-964a-465a471c7d37": "SKU1234",
    "b6d74510-41ce-42ec-947a-0bdf62e9beee": "Refrigerateur",
    "ba270fa0-8482-46be-905a-cae4ca746b92": "http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v2/user/catalogs/:storeId/customColumns/computeExpression", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression"

payload = {
    "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
    "productValues": {
        "012929c0-e78b-462a-a96e-25c061575385": "http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg",
        "46602e10-bc45-4944-a440-63d5f7ece1f8": "42",
        "68082b11-4ffd-4bec-964a-465a471c7d37": "SKU1234",
        "b6d74510-41ce-42ec-947a-0bdf62e9beee": "Refrigerateur",
        "ba270fa0-8482-46be-905a-cae4ca746b92": "http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression"

payload <- "{\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\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}}/v2/user/catalogs/:storeId/customColumns/computeExpression")

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  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\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/v2/user/catalogs/:storeId/customColumns/computeExpression') do |req|
  req.body = "{\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"productValues\": {\n    \"012929c0-e78b-462a-a96e-25c061575385\": \"http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg\",\n    \"46602e10-bc45-4944-a440-63d5f7ece1f8\": \"42\",\n    \"68082b11-4ffd-4bec-964a-465a471c7d37\": \"SKU1234\",\n    \"b6d74510-41ce-42ec-947a-0bdf62e9beee\": \"Refrigerateur\",\n    \"ba270fa0-8482-46be-905a-cae4ca746b92\": \"http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression";

    let payload = json!({
        "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
        "productValues": json!({
            "012929c0-e78b-462a-a96e-25c061575385": "http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg",
            "46602e10-bc45-4944-a440-63d5f7ece1f8": "42",
            "68082b11-4ffd-4bec-964a-465a471c7d37": "SKU1234",
            "b6d74510-41ce-42ec-947a-0bdf62e9beee": "Refrigerateur",
            "ba270fa0-8482-46be-905a-cae4ca746b92": "http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"
        })
    });

    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);
}

echo '{
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "productValues": {
    "012929c0-e78b-462a-a96e-25c061575385": "http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg",
    "46602e10-bc45-4944-a440-63d5f7ece1f8": "42",
    "68082b11-4ffd-4bec-964a-465a471c7d37": "SKU1234",
    "b6d74510-41ce-42ec-947a-0bdf62e9beee": "Refrigerateur",
    "ba270fa0-8482-46be-905a-cae4ca746b92": "http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"
  }
}' |  \
  http POST {{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",\n  "productValues": {\n    "012929c0-e78b-462a-a96e-25c061575385": "http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg",\n    "46602e10-bc45-4944-a440-63d5f7ece1f8": "42",\n    "68082b11-4ffd-4bec-964a-465a471c7d37": "SKU1234",\n    "b6d74510-41ce-42ec-947a-0bdf62e9beee": "Refrigerateur",\n    "ba270fa0-8482-46be-905a-cae4ca746b92": "http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "productValues": [
    "012929c0-e78b-462a-a96e-25c061575385": "http://media.conforama.fr/Medias/500000/80000/5000/500/10/G_585511_A.jpg",
    "46602e10-bc45-4944-a440-63d5f7ece1f8": "42",
    "68082b11-4ffd-4bec-964a-465a471c7d37": "SKU1234",
    "b6d74510-41ce-42ec-947a-0bdf62e9beee": "Refrigerateur",
    "ba270fa0-8482-46be-905a-cae4ca746b92": "http://www.conforama.fr/gros-electromenager/encastrable/refrigerateur-encastrable/refrigerateur-combine-161-litres-far-r5115s/p/585511"
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/computeExpression")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId");

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  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId" {:content-type :json
                                                                                             :form-params {:displayGroupName "Category"
                                                                                                           :encryptedBlocklyExpression "apokpoa,opz,sixsoisiosnoisn"
                                                                                                           :encryptedExpression "uziushdczaniodnndonisodndsiondsoidsndoin"
                                                                                                           :userColumnName "My SKU"}})

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"),
    Content = new StringContent("{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\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}}/v2/user/catalogs/:storeId/customColumns/:columnId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"

	payload := strings.NewReader("{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/v2/user/catalogs/:storeId/customColumns/:columnId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 198

{
  "displayGroupName": "Category",
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "userColumnName": "My SKU"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\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  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")
  .header("content-type", "application/json")
  .body("{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}")
  .asString();

const data = JSON.stringify({
  displayGroupName: 'Category',
  encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
  encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
  userColumnName: 'My SKU'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId',
  headers: {'content-type': 'application/json'},
  data: {
    displayGroupName: 'Category',
    encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
    encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
    userColumnName: 'My SKU'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"displayGroupName":"Category","encryptedBlocklyExpression":"apokpoa,opz,sixsoisiosnoisn","encryptedExpression":"uziushdczaniodnndonisodndsiondsoidsndoin","userColumnName":"My SKU"}'
};

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}}/v2/user/catalogs/:storeId/customColumns/:columnId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "displayGroupName": "Category",\n  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",\n  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",\n  "userColumnName": "My SKU"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/customColumns/:columnId',
  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({
  displayGroupName: 'Category',
  encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
  encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
  userColumnName: 'My SKU'
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId',
  headers: {'content-type': 'application/json'},
  body: {
    displayGroupName: 'Category',
    encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
    encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
    userColumnName: 'My SKU'
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  displayGroupName: 'Category',
  encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
  encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
  userColumnName: 'My SKU'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId',
  headers: {'content-type': 'application/json'},
  data: {
    displayGroupName: 'Category',
    encryptedBlocklyExpression: 'apokpoa,opz,sixsoisiosnoisn',
    encryptedExpression: 'uziushdczaniodnndonisodndsiondsoidsndoin',
    userColumnName: 'My SKU'
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"displayGroupName":"Category","encryptedBlocklyExpression":"apokpoa,opz,sixsoisiosnoisn","encryptedExpression":"uziushdczaniodnndonisodndsiondsoidsndoin","userColumnName":"My SKU"}'
};

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 = @{ @"displayGroupName": @"Category",
                              @"encryptedBlocklyExpression": @"apokpoa,opz,sixsoisiosnoisn",
                              @"encryptedExpression": @"uziushdczaniodnndonisodndsiondsoidsndoin",
                              @"userColumnName": @"My SKU" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'displayGroupName' => 'Category',
    'encryptedBlocklyExpression' => 'apokpoa,opz,sixsoisiosnoisn',
    'encryptedExpression' => 'uziushdczaniodnndonisodndsiondsoidsndoin',
    'userColumnName' => 'My SKU'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId', [
  'body' => '{
  "displayGroupName": "Category",
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "userColumnName": "My SKU"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'displayGroupName' => 'Category',
  'encryptedBlocklyExpression' => 'apokpoa,opz,sixsoisiosnoisn',
  'encryptedExpression' => 'uziushdczaniodnndonisodndsiondsoidsndoin',
  'userColumnName' => 'My SKU'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'displayGroupName' => 'Category',
  'encryptedBlocklyExpression' => 'apokpoa,opz,sixsoisiosnoisn',
  'encryptedExpression' => 'uziushdczaniodnndonisodndsiondsoidsndoin',
  'userColumnName' => 'My SKU'
]));
$request->setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "displayGroupName": "Category",
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "userColumnName": "My SKU"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "displayGroupName": "Category",
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "userColumnName": "My SKU"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/v2/user/catalogs/:storeId/customColumns/:columnId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"

payload = {
    "displayGroupName": "Category",
    "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
    "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
    "userColumnName": "My SKU"
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"

payload <- "{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/v2/user/catalogs/:storeId/customColumns/:columnId') do |req|
  req.body = "{\n  \"displayGroupName\": \"Category\",\n  \"encryptedBlocklyExpression\": \"apokpoa,opz,sixsoisiosnoisn\",\n  \"encryptedExpression\": \"uziushdczaniodnndonisodndsiondsoidsndoin\",\n  \"userColumnName\": \"My SKU\"\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}}/v2/user/catalogs/:storeId/customColumns/:columnId";

    let payload = json!({
        "displayGroupName": "Category",
        "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
        "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
        "userColumnName": "My SKU"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "displayGroupName": "Category",
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "userColumnName": "My SKU"
}' |  \
  http PUT {{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "displayGroupName": "Category",\n  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",\n  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",\n  "userColumnName": "My SKU"\n}' \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "displayGroupName": "Category",
  "encryptedBlocklyExpression": "apokpoa,opz,sixsoisiosnoisn",
  "encryptedExpression": "uziushdczaniodnndonisodndsiondsoidsndoin",
  "userColumnName": "My SKU"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"

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}}/v2/user/catalogs/:storeId/customColumns/:columnId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"

	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/v2/user/catalogs/:storeId/customColumns/:columnId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"))
    .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}}/v2/user/catalogs/:storeId/customColumns/:columnId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")
  .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}}/v2/user/catalogs/:storeId/customColumns/:columnId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId';
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}}/v2/user/catalogs/:storeId/customColumns/:columnId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/customColumns/:columnId',
  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}}/v2/user/catalogs/:storeId/customColumns/:columnId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId');

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}}/v2/user/catalogs/:storeId/customColumns/:columnId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId';
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}}/v2/user/catalogs/:storeId/customColumns/:columnId"]
                                                       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}}/v2/user/catalogs/:storeId/customColumns/:columnId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId",
  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}}/v2/user/catalogs/:storeId/customColumns/:columnId');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v2/user/catalogs/:storeId/customColumns/:columnId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")

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/v2/user/catalogs/:storeId/customColumns/:columnId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId";

    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);
}

http DELETE {{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns/:columnId")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns")

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns"

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}}/v2/user/catalogs/:storeId/catalogColumns"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns"

	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/v2/user/catalogs/:storeId/catalogColumns HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns"))
    .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}}/v2/user/catalogs/:storeId/catalogColumns")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns")
  .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}}/v2/user/catalogs/:storeId/catalogColumns');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns';
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}}/v2/user/catalogs/:storeId/catalogColumns',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/catalogColumns',
  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}}/v2/user/catalogs/:storeId/catalogColumns'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns');

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}}/v2/user/catalogs/:storeId/catalogColumns'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns';
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}}/v2/user/catalogs/:storeId/catalogColumns"]
                                                       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}}/v2/user/catalogs/:storeId/catalogColumns" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns",
  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}}/v2/user/catalogs/:storeId/catalogColumns');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/user/catalogs/:storeId/catalogColumns")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns")

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/v2/user/catalogs/:storeId/catalogColumns') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/catalogColumns")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/categories");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept-encoding: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/user/catalogs/:storeId/categories" {:headers {:accept-encoding ""}})

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/categories"
headers = HTTP::Headers{
  "accept-encoding" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v2/user/catalogs/:storeId/categories"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/categories");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept-encoding", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/categories"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept-encoding", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v2/user/catalogs/:storeId/categories HTTP/1.1
Accept-Encoding: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/catalogs/:storeId/categories")
  .setHeader("accept-encoding", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/categories"))
    .header("accept-encoding", "")
    .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}}/v2/user/catalogs/:storeId/categories")
  .get()
  .addHeader("accept-encoding", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/catalogs/:storeId/categories")
  .header("accept-encoding", "")
  .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}}/v2/user/catalogs/:storeId/categories');
xhr.setRequestHeader('accept-encoding', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/categories',
  headers: {'accept-encoding': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/categories';
const options = {method: 'GET', headers: {'accept-encoding': ''}};

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}}/v2/user/catalogs/:storeId/categories',
  method: 'GET',
  headers: {
    'accept-encoding': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/categories")
  .get()
  .addHeader("accept-encoding", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/categories',
  headers: {
    'accept-encoding': ''
  }
};

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}}/v2/user/catalogs/:storeId/categories',
  headers: {'accept-encoding': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/catalogs/:storeId/categories');

req.headers({
  'accept-encoding': ''
});

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}}/v2/user/catalogs/:storeId/categories',
  headers: {'accept-encoding': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/categories';
const options = {method: 'GET', headers: {'accept-encoding': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept-encoding": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v2/user/catalogs/:storeId/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/v2/user/catalogs/:storeId/categories" in
let headers = Header.add (Header.init ()) "accept-encoding" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept-encoding: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v2/user/catalogs/:storeId/categories', [
  'headers' => [
    'accept-encoding' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/categories');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept-encoding' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/categories');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept-encoding' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept-encoding", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/categories' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept-encoding", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/categories' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'accept-encoding': "" }

conn.request("GET", "/baseUrl/v2/user/catalogs/:storeId/categories", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/categories"

headers = {"accept-encoding": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/categories"

response <- VERB("GET", url, add_headers('accept-encoding' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/categories")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept-encoding"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v2/user/catalogs/:storeId/categories') do |req|
  req.headers['accept-encoding'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/categories";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept-encoding", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/catalogs/:storeId/categories \
  accept-encoding:''

wget --quiet \
  --method GET \
  --header 'accept-encoding: ' \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/categories

import Foundation

let headers = ["accept-encoding": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns")

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns"

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}}/v2/user/catalogs/:storeId/customColumns"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns"

	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/v2/user/catalogs/:storeId/customColumns HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns"))
    .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}}/v2/user/catalogs/:storeId/customColumns")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns")
  .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}}/v2/user/catalogs/:storeId/customColumns');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns';
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}}/v2/user/catalogs/:storeId/customColumns',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/customColumns',
  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}}/v2/user/catalogs/:storeId/customColumns'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns');

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}}/v2/user/catalogs/:storeId/customColumns'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns';
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}}/v2/user/catalogs/:storeId/customColumns"]
                                                       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}}/v2/user/catalogs/:storeId/customColumns" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns",
  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}}/v2/user/catalogs/:storeId/customColumns');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/customColumns');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/customColumns' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/user/catalogs/:storeId/customColumns")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/customColumns")

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/v2/user/catalogs/:storeId/customColumns') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/catalogs/:storeId/customColumns

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/customColumns

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/customColumns")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId")

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId"

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}}/v2/user/catalogs/:storeId/products/:productId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId"

	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/v2/user/catalogs/:storeId/products/:productId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId"))
    .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}}/v2/user/catalogs/:storeId/products/:productId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId")
  .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}}/v2/user/catalogs/:storeId/products/:productId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId';
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}}/v2/user/catalogs/:storeId/products/:productId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/products/:productId',
  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}}/v2/user/catalogs/:storeId/products/:productId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId');

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}}/v2/user/catalogs/:storeId/products/:productId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId';
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}}/v2/user/catalogs/:storeId/products/:productId"]
                                                       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}}/v2/user/catalogs/:storeId/products/:productId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId",
  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}}/v2/user/catalogs/:storeId/products/:productId');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/user/catalogs/:storeId/products/:productId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId")

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/v2/user/catalogs/:storeId/products/:productId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v2/user/catalogs/:storeId/products/:productId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v2/user/catalogs/:storeId/products/:productId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v2/user/catalogs/:storeId/products/:productId")! 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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v2/user/catalogs/:storeId/products?sku=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v2/user/catalogs/:storeId/products" {:query-params {:sku ""}})

require "http/client"

url = "{{baseUrl}}/v2/user/catalogs/:storeId/products?sku="

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}}/v2/user/catalogs/:storeId/products?sku="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v2/user/catalogs/:storeId/products?sku=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v2/user/catalogs/:storeId/products?sku="

	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/v2/user/catalogs/:storeId/products?sku= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v2/user/catalogs/:storeId/products?sku=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v2/user/catalogs/:storeId/products?sku="))
    .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}}/v2/user/catalogs/:storeId/products?sku=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v2/user/catalogs/:storeId/products?sku=")
  .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}}/v2/user/catalogs/:storeId/products?sku=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/v2/user/catalogs/:storeId/products',
  params: {sku: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/products?sku=';
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}}/v2/user/catalogs/:storeId/products?sku=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v2/user/catalogs/:storeId/products?sku=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v2/user/catalogs/:storeId/products?sku=',
  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}}/v2/user/catalogs/:storeId/products',
  qs: {sku: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v2/user/catalogs/:storeId/products');

req.query({
  sku: ''
});

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}}/v2/user/catalogs/:storeId/products',
  params: {sku: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v2/user/catalogs/:storeId/products?sku=';
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}}/v2/user/catalogs/:storeId/products?sku="]
                                                       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}}/v2/user/catalogs/:storeId/products?sku=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v2/user/catalogs/:storeId/products?sku=",
  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}}/v2/user/catalogs/:storeId/products?sku=');

echo $response->getBody();

setUrl('{{baseUrl}}/v2/user/catalogs/:storeId/products');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'sku' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v2/user/catalogs/:storeId/products');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'sku' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/products?sku=' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v2/user/catalogs/:storeId/products?sku=' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v2/user/catalogs/:storeId/products?sku=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v2/user/catalogs/:storeId/products"

querystring = {"sku":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v2/user/catalogs/:storeId/products"

queryString <- list(sku = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v2/user/catalogs/:storeId/products?sku=")

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/v2/user/catalogs/:storeId/products') do |req|
  req.params['sku'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v2/user/catalogs/:storeId/products";

    let querystring = [
        ("sku", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}