CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"signature\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/" {:headers {:sessionid "{{apiKey}}"}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:signature ""}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"signature\": \"\"\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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"signature\": \"\"\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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/");
var request = new RestRequest("", Method.Post);
request.AddHeader("sessionid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"signature\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"

	payload := strings.NewReader("{\n  \"signature\": \"\"\n}")

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

	req.Header.Add("sessionid", "{{apiKey}}")
	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/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/ HTTP/1.1
Sessionid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "signature": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")
  .setHeader("sessionid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"signature\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"))
    .header("sessionid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"signature\": \"\"\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  \"signature\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")
  .header("sessionid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"signature\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {signature: ''}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"signature":""}'
};

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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/',
  method: 'POST',
  headers: {
    sessionid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "signature": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"signature\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .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/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/',
  headers: {
    sessionid: '{{apiKey}}',
    '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({signature: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {signature: ''},
  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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/');

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

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

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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {signature: ''}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"signature":""}'
};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"signature": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"]
                                                       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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/" in
let headers = Header.add_list (Header.init ()) [
  ("sessionid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"signature\": \"\"\n}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/",
  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([
    'signature' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/', [
  'body' => '{
  "signature": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  'signature' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "signature": ""
}'

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "signature": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"

payload = { "signature": "" }
headers = {
    "sessionid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"

payload <- "{\n  \"signature\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('sessionid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")

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

request = Net::HTTP::Post.new(url)
request["sessionid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"signature\": \"\"\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/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
  req.body = "{\n  \"signature\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());
    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 '{
  "signature": ""
}' |  \
  http POST {{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/ \
  content-type:application/json \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'sessionid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "signature": ""\n}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/

import Foundation

let headers = [
  "sessionid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["signature": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"]
                                                       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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/confirmations/")! 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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/"]
                                                       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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safe-operations/:safe_operation_hash/")! 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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/" {:headers {:sessionid "{{apiKey}}"}
                                                                                                  :content-type :json
                                                                                                  :form-params {:nonce 0
                                                                                                                :initCode ""
                                                                                                                :callData ""
                                                                                                                :callGasLimit 0
                                                                                                                :verificationGasLimit 0
                                                                                                                :preVerificationGas 0
                                                                                                                :maxFeePerGas 0
                                                                                                                :maxPriorityFeePerGas 0
                                                                                                                :paymasterAndData ""
                                                                                                                :signature ""
                                                                                                                :entryPoint ""
                                                                                                                :validAfter ""
                                                                                                                :validUntil ""
                                                                                                                :moduleAddress ""}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\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}}/tx-service/gno/api/v1/safes/:address/safe-operations/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\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}}/tx-service/gno/api/v1/safes/:address/safe-operations/");
var request = new RestRequest("", Method.Post);
request.AddHeader("sessionid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"

	payload := strings.NewReader("{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\n}")

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

	req.Header.Add("sessionid", "{{apiKey}}")
	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/tx-service/gno/api/v1/safes/:address/safe-operations/ HTTP/1.1
Sessionid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 307

{
  "nonce": 0,
  "initCode": "",
  "callData": "",
  "callGasLimit": 0,
  "verificationGasLimit": 0,
  "preVerificationGas": 0,
  "maxFeePerGas": 0,
  "maxPriorityFeePerGas": 0,
  "paymasterAndData": "",
  "signature": "",
  "entryPoint": "",
  "validAfter": "",
  "validUntil": "",
  "moduleAddress": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/")
  .setHeader("sessionid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"))
    .header("sessionid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\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  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/")
  .header("sessionid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  nonce: 0,
  initCode: '',
  callData: '',
  callGasLimit: 0,
  verificationGasLimit: 0,
  preVerificationGas: 0,
  maxFeePerGas: 0,
  maxPriorityFeePerGas: 0,
  paymasterAndData: '',
  signature: '',
  entryPoint: '',
  validAfter: '',
  validUntil: '',
  moduleAddress: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    nonce: 0,
    initCode: '',
    callData: '',
    callGasLimit: 0,
    verificationGasLimit: 0,
    preVerificationGas: 0,
    maxFeePerGas: 0,
    maxPriorityFeePerGas: 0,
    paymasterAndData: '',
    signature: '',
    entryPoint: '',
    validAfter: '',
    validUntil: '',
    moduleAddress: ''
  }
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"nonce":0,"initCode":"","callData":"","callGasLimit":0,"verificationGasLimit":0,"preVerificationGas":0,"maxFeePerGas":0,"maxPriorityFeePerGas":0,"paymasterAndData":"","signature":"","entryPoint":"","validAfter":"","validUntil":"","moduleAddress":""}'
};

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}}/tx-service/gno/api/v1/safes/:address/safe-operations/',
  method: 'POST',
  headers: {
    sessionid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "nonce": 0,\n  "initCode": "",\n  "callData": "",\n  "callGasLimit": 0,\n  "verificationGasLimit": 0,\n  "preVerificationGas": 0,\n  "maxFeePerGas": 0,\n  "maxPriorityFeePerGas": 0,\n  "paymasterAndData": "",\n  "signature": "",\n  "entryPoint": "",\n  "validAfter": "",\n  "validUntil": "",\n  "moduleAddress": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .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/tx-service/gno/api/v1/safes/:address/safe-operations/',
  headers: {
    sessionid: '{{apiKey}}',
    '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({
  nonce: 0,
  initCode: '',
  callData: '',
  callGasLimit: 0,
  verificationGasLimit: 0,
  preVerificationGas: 0,
  maxFeePerGas: 0,
  maxPriorityFeePerGas: 0,
  paymasterAndData: '',
  signature: '',
  entryPoint: '',
  validAfter: '',
  validUntil: '',
  moduleAddress: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {
    nonce: 0,
    initCode: '',
    callData: '',
    callGasLimit: 0,
    verificationGasLimit: 0,
    preVerificationGas: 0,
    maxFeePerGas: 0,
    maxPriorityFeePerGas: 0,
    paymasterAndData: '',
    signature: '',
    entryPoint: '',
    validAfter: '',
    validUntil: '',
    moduleAddress: ''
  },
  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}}/tx-service/gno/api/v1/safes/:address/safe-operations/');

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

req.type('json');
req.send({
  nonce: 0,
  initCode: '',
  callData: '',
  callGasLimit: 0,
  verificationGasLimit: 0,
  preVerificationGas: 0,
  maxFeePerGas: 0,
  maxPriorityFeePerGas: 0,
  paymasterAndData: '',
  signature: '',
  entryPoint: '',
  validAfter: '',
  validUntil: '',
  moduleAddress: ''
});

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}}/tx-service/gno/api/v1/safes/:address/safe-operations/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    nonce: 0,
    initCode: '',
    callData: '',
    callGasLimit: 0,
    verificationGasLimit: 0,
    preVerificationGas: 0,
    maxFeePerGas: 0,
    maxPriorityFeePerGas: 0,
    paymasterAndData: '',
    signature: '',
    entryPoint: '',
    validAfter: '',
    validUntil: '',
    moduleAddress: ''
  }
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"nonce":0,"initCode":"","callData":"","callGasLimit":0,"verificationGasLimit":0,"preVerificationGas":0,"maxFeePerGas":0,"maxPriorityFeePerGas":0,"paymasterAndData":"","signature":"","entryPoint":"","validAfter":"","validUntil":"","moduleAddress":""}'
};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"nonce": @0,
                              @"initCode": @"",
                              @"callData": @"",
                              @"callGasLimit": @0,
                              @"verificationGasLimit": @0,
                              @"preVerificationGas": @0,
                              @"maxFeePerGas": @0,
                              @"maxPriorityFeePerGas": @0,
                              @"paymasterAndData": @"",
                              @"signature": @"",
                              @"entryPoint": @"",
                              @"validAfter": @"",
                              @"validUntil": @"",
                              @"moduleAddress": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/safe-operations/" in
let headers = Header.add_list (Header.init ()) [
  ("sessionid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\n}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/",
  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([
    'nonce' => 0,
    'initCode' => '',
    'callData' => '',
    'callGasLimit' => 0,
    'verificationGasLimit' => 0,
    'preVerificationGas' => 0,
    'maxFeePerGas' => 0,
    'maxPriorityFeePerGas' => 0,
    'paymasterAndData' => '',
    'signature' => '',
    'entryPoint' => '',
    'validAfter' => '',
    'validUntil' => '',
    'moduleAddress' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/', [
  'body' => '{
  "nonce": 0,
  "initCode": "",
  "callData": "",
  "callGasLimit": 0,
  "verificationGasLimit": 0,
  "preVerificationGas": 0,
  "maxFeePerGas": 0,
  "maxPriorityFeePerGas": 0,
  "paymasterAndData": "",
  "signature": "",
  "entryPoint": "",
  "validAfter": "",
  "validUntil": "",
  "moduleAddress": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'nonce' => 0,
  'initCode' => '',
  'callData' => '',
  'callGasLimit' => 0,
  'verificationGasLimit' => 0,
  'preVerificationGas' => 0,
  'maxFeePerGas' => 0,
  'maxPriorityFeePerGas' => 0,
  'paymasterAndData' => '',
  'signature' => '',
  'entryPoint' => '',
  'validAfter' => '',
  'validUntil' => '',
  'moduleAddress' => ''
]));

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

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

append(json_encode([
  'nonce' => 0,
  'initCode' => '',
  'callData' => '',
  'callGasLimit' => 0,
  'verificationGasLimit' => 0,
  'preVerificationGas' => 0,
  'maxFeePerGas' => 0,
  'maxPriorityFeePerGas' => 0,
  'paymasterAndData' => '',
  'signature' => '',
  'entryPoint' => '',
  'validAfter' => '',
  'validUntil' => '',
  'moduleAddress' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nonce": 0,
  "initCode": "",
  "callData": "",
  "callGasLimit": 0,
  "verificationGasLimit": 0,
  "preVerificationGas": 0,
  "maxFeePerGas": 0,
  "maxPriorityFeePerGas": 0,
  "paymasterAndData": "",
  "signature": "",
  "entryPoint": "",
  "validAfter": "",
  "validUntil": "",
  "moduleAddress": ""
}'

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nonce": 0,
  "initCode": "",
  "callData": "",
  "callGasLimit": 0,
  "verificationGasLimit": 0,
  "preVerificationGas": 0,
  "maxFeePerGas": 0,
  "maxPriorityFeePerGas": 0,
  "paymasterAndData": "",
  "signature": "",
  "entryPoint": "",
  "validAfter": "",
  "validUntil": "",
  "moduleAddress": ""
}'

import http.client

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

payload = "{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\n}"

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

conn.request("POST", "/baseUrl/tx-service/gno/api/v1/safes/:address/safe-operations/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"

payload = {
    "nonce": 0,
    "initCode": "",
    "callData": "",
    "callGasLimit": 0,
    "verificationGasLimit": 0,
    "preVerificationGas": 0,
    "maxFeePerGas": 0,
    "maxPriorityFeePerGas": 0,
    "paymasterAndData": "",
    "signature": "",
    "entryPoint": "",
    "validAfter": "",
    "validUntil": "",
    "moduleAddress": ""
}
headers = {
    "sessionid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"

payload <- "{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('sessionid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/")

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

request = Net::HTTP::Post.new(url)
request["sessionid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\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/tx-service/gno/api/v1/safes/:address/safe-operations/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
  req.body = "{\n  \"nonce\": 0,\n  \"initCode\": \"\",\n  \"callData\": \"\",\n  \"callGasLimit\": 0,\n  \"verificationGasLimit\": 0,\n  \"preVerificationGas\": 0,\n  \"maxFeePerGas\": 0,\n  \"maxPriorityFeePerGas\": 0,\n  \"paymasterAndData\": \"\",\n  \"signature\": \"\",\n  \"entryPoint\": \"\",\n  \"validAfter\": \"\",\n  \"validUntil\": \"\",\n  \"moduleAddress\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/";

    let payload = json!({
        "nonce": 0,
        "initCode": "",
        "callData": "",
        "callGasLimit": 0,
        "verificationGasLimit": 0,
        "preVerificationGas": 0,
        "maxFeePerGas": 0,
        "maxPriorityFeePerGas": 0,
        "paymasterAndData": "",
        "signature": "",
        "entryPoint": "",
        "validAfter": "",
        "validUntil": "",
        "moduleAddress": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());
    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 '{
  "nonce": 0,
  "initCode": "",
  "callData": "",
  "callGasLimit": 0,
  "verificationGasLimit": 0,
  "preVerificationGas": 0,
  "maxFeePerGas": 0,
  "maxPriorityFeePerGas": 0,
  "paymasterAndData": "",
  "signature": "",
  "entryPoint": "",
  "validAfter": "",
  "validUntil": "",
  "moduleAddress": ""
}' |  \
  http POST {{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/ \
  content-type:application/json \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'sessionid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "nonce": 0,\n  "initCode": "",\n  "callData": "",\n  "callGasLimit": 0,\n  "verificationGasLimit": 0,\n  "preVerificationGas": 0,\n  "maxFeePerGas": 0,\n  "maxPriorityFeePerGas": 0,\n  "paymasterAndData": "",\n  "signature": "",\n  "entryPoint": "",\n  "validAfter": "",\n  "validUntil": "",\n  "moduleAddress": ""\n}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/

import Foundation

let headers = [
  "sessionid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "nonce": 0,
  "initCode": "",
  "callData": "",
  "callGasLimit": 0,
  "verificationGasLimit": 0,
  "preVerificationGas": 0,
  "maxFeePerGas": 0,
  "maxPriorityFeePerGas": 0,
  "paymasterAndData": "",
  "signature": "",
  "entryPoint": "",
  "validAfter": "",
  "validUntil": "",
  "moduleAddress": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safes/:address/safe-operations/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/safes/:address/safe-operations/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safes/:address/safe-operations/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safes/:address/safe-operations/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safes/:address/safe-operations/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safes/:address/safe-operations/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safes/:address/safe-operations/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safes/:address/safe-operations/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/safe-operations/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safes/:address/safe-operations/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/safes/:address/safe-operations/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safes/:address/safe-operations/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/safe-operations/")! 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}}/tx-service/gno/api/v1/safes/:address/user-operations/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safes/:address/user-operations/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/safes/:address/user-operations/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safes/:address/user-operations/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safes/:address/user-operations/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safes/:address/user-operations/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safes/:address/user-operations/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safes/:address/user-operations/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safes/:address/user-operations/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/user-operations/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safes/:address/user-operations/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/safes/:address/user-operations/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safes/:address/user-operations/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/user-operations/")! 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}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/user-operations/:user_operation_hash/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/user-operations/:user_operation_hash/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/"]
                                                       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}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/user-operations/:user_operation_hash/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/user-operations/:user_operation_hash/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/user-operations/:user_operation_hash/")! 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}}/tx-service/gno/api/v1/about/deployments/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/about/deployments/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/about/deployments/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/about/deployments/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/about/deployments/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/about/deployments/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/about/deployments/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/about/deployments/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/about/deployments/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/about/deployments/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/about/deployments/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/about/deployments/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/about/deployments/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/deployments/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/about/deployments/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/about/deployments/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/about/deployments/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/about/deployments/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/deployments/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/about/deployments/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/deployments/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/about/deployments/"]
                                                       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}}/tx-service/gno/api/v1/about/deployments/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/about/deployments/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/deployments/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/about/deployments/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/about/deployments/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/deployments/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/deployments/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/about/deployments/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/about/deployments/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/about/deployments/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/about/deployments/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/about/deployments/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/about/deployments/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/about/deployments/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/about/deployments/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/about/deployments/")! 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}}/tx-service/gno/api/v1/about/ethereum-rpc/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/about/ethereum-rpc/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/about/ethereum-rpc/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/about/ethereum-rpc/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/about/ethereum-rpc/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/about/ethereum-rpc/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/about/ethereum-rpc/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/about/ethereum-rpc/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/about/ethereum-rpc/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/"]
                                                       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}}/tx-service/gno/api/v1/about/ethereum-rpc/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/about/ethereum-rpc/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/about/ethereum-rpc/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/about/ethereum-rpc/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-rpc/")! 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}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/about/ethereum-tracing-rpc/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/about/ethereum-tracing-rpc/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/"]
                                                       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}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/about/ethereum-tracing-rpc/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/about/ethereum-tracing-rpc/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/about/ethereum-tracing-rpc/")! 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}}/tx-service/gno/api/v1/about/indexing/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/about/indexing/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/about/indexing/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/about/indexing/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/about/indexing/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/about/indexing/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/about/indexing/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/about/indexing/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/about/indexing/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/about/indexing/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/about/indexing/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/about/indexing/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/about/indexing/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/indexing/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/about/indexing/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/about/indexing/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/about/indexing/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/about/indexing/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/indexing/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/about/indexing/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/indexing/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/about/indexing/"]
                                                       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}}/tx-service/gno/api/v1/about/indexing/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/about/indexing/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/indexing/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/about/indexing/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/about/indexing/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/indexing/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/indexing/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/about/indexing/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/about/indexing/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/about/indexing/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/about/indexing/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/about/indexing/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/about/indexing/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/about/indexing/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/about/indexing/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/about/indexing/")! 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}}/tx-service/gno/api/v1/about/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/about/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/about/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/about/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/about/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/about/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/about/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/about/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/about/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/about/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/about/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/about/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/about/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/about/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/about/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/about/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/about/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/about/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/about/"]
                                                       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}}/tx-service/gno/api/v1/about/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/about/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/about/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/about/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/about/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/about/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/about/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/about/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/about/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/about/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/about/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/about/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/about/")! 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}}/tx-service/gno/api/v1/about/singletons/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/about/singletons/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/about/singletons/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/about/singletons/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/about/singletons/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/about/singletons/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/about/singletons/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/about/singletons/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/about/singletons/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/about/singletons/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/about/singletons/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/about/singletons/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/about/singletons/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/singletons/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/about/singletons/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/about/singletons/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/about/singletons/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/about/singletons/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/singletons/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/about/singletons/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/about/singletons/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/about/singletons/"]
                                                       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}}/tx-service/gno/api/v1/about/singletons/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/about/singletons/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/about/singletons/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/about/singletons/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/about/singletons/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/singletons/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/about/singletons/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/about/singletons/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/about/singletons/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/about/singletons/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/about/singletons/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/about/singletons/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/about/singletons/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/about/singletons/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/about/singletons/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/about/singletons/")! 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}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/" {:headers {:authorization "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/"

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

	req.Header.Add("authorization", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/ HTTP/1.1
Authorization: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/")
  .setHeader("authorization", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/"))
    .header("authorization", "{{apiKey}}")
    .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}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/")
  .header("authorization", "{{apiKey}}")
  .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}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/');
xhr.setRequestHeader('authorization', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/',
  headers: {authorization: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

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}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/',
  method: 'GET',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/',
  headers: {authorization: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/');

req.headers({
  authorization: '{{apiKey}}'
});

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}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/',
  headers: {authorization: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/"]
                                                       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}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/', [
  'headers' => [
    'authorization' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/' -Method GET -Headers $headers

import http.client

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

headers = { 'authorization': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/"

headers = {"authorization": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/"

response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/') do |req|
  req.headers['authorization'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".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}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/ \
  authorization:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'authorization: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/

import Foundation

let headers = ["authorization": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v2/analytics/multisig-transactions/by-origin/")! 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}}/tx-service/gno/api/v1/contracts/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/contracts/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/contracts/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/contracts/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/contracts/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/contracts/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/contracts/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/contracts/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/contracts/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/contracts/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/contracts/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/contracts/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/contracts/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/contracts/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/contracts/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/contracts/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/contracts/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/contracts/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/contracts/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/contracts/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/contracts/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/contracts/"]
                                                       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}}/tx-service/gno/api/v1/contracts/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/contracts/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/contracts/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/contracts/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/contracts/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/contracts/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/contracts/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/contracts/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/contracts/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/contracts/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/contracts/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/contracts/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/contracts/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/contracts/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/contracts/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/contracts/")! 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}}/tx-service/gno/api/v1/contracts/:address/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/contracts/:address/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/contracts/:address/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/contracts/:address/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/contracts/:address/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/contracts/:address/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/contracts/:address/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/contracts/:address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/contracts/:address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/"]
                                                       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}}/tx-service/gno/api/v1/contracts/:address/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/contracts/:address/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/contracts/:address/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/contracts/:address/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/contracts/:address/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/contracts/:address/")! 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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/data-decoder/");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"data\": \"\",\n  \"to\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/tx-service/gno/api/v1/data-decoder/" {:headers {:sessionid "{{apiKey}}"}
                                                                                :content-type :json
                                                                                :form-params {:data ""
                                                                                              :to ""}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/data-decoder/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"data\": \"\",\n  \"to\": \"\"\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}}/tx-service/gno/api/v1/data-decoder/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"data\": \"\",\n  \"to\": \"\"\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}}/tx-service/gno/api/v1/data-decoder/");
var request = new RestRequest("", Method.Post);
request.AddHeader("sessionid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"data\": \"\",\n  \"to\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/data-decoder/"

	payload := strings.NewReader("{\n  \"data\": \"\",\n  \"to\": \"\"\n}")

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

	req.Header.Add("sessionid", "{{apiKey}}")
	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/tx-service/gno/api/v1/data-decoder/ HTTP/1.1
Sessionid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "data": "",
  "to": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tx-service/gno/api/v1/data-decoder/")
  .setHeader("sessionid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"data\": \"\",\n  \"to\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/data-decoder/"))
    .header("sessionid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"data\": \"\",\n  \"to\": \"\"\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  \"data\": \"\",\n  \"to\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/data-decoder/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/tx-service/gno/api/v1/data-decoder/")
  .header("sessionid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"data\": \"\",\n  \"to\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/tx-service/gno/api/v1/data-decoder/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/data-decoder/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: '', to: ''}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/data-decoder/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":"","to":""}'
};

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}}/tx-service/gno/api/v1/data-decoder/',
  method: 'POST',
  headers: {
    sessionid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "data": "",\n  "to": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"data\": \"\",\n  \"to\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/data-decoder/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .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/tx-service/gno/api/v1/data-decoder/',
  headers: {
    sessionid: '{{apiKey}}',
    '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({data: '', to: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/data-decoder/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {data: '', to: ''},
  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}}/tx-service/gno/api/v1/data-decoder/');

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

req.type('json');
req.send({
  data: '',
  to: ''
});

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}}/tx-service/gno/api/v1/data-decoder/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: '', to: ''}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/data-decoder/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":"","to":""}'
};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"data": @"",
                              @"to": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/data-decoder/"]
                                                       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}}/tx-service/gno/api/v1/data-decoder/" in
let headers = Header.add_list (Header.init ()) [
  ("sessionid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"data\": \"\",\n  \"to\": \"\"\n}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/data-decoder/",
  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([
    'data' => '',
    'to' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/tx-service/gno/api/v1/data-decoder/', [
  'body' => '{
  "data": "",
  "to": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/data-decoder/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  'data' => '',
  'to' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/data-decoder/');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/data-decoder/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "data": "",
  "to": ""
}'

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/data-decoder/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "data": "",
  "to": ""
}'

import http.client

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

payload = "{\n  \"data\": \"\",\n  \"to\": \"\"\n}"

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

conn.request("POST", "/baseUrl/tx-service/gno/api/v1/data-decoder/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/data-decoder/"

payload = {
    "data": "",
    "to": ""
}
headers = {
    "sessionid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/data-decoder/"

payload <- "{\n  \"data\": \"\",\n  \"to\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('sessionid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/data-decoder/")

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

request = Net::HTTP::Post.new(url)
request["sessionid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"data\": \"\",\n  \"to\": \"\"\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/tx-service/gno/api/v1/data-decoder/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
  req.body = "{\n  \"data\": \"\",\n  \"to\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/data-decoder/";

    let payload = json!({
        "data": "",
        "to": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());
    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 '{
  "data": "",
  "to": ""
}' |  \
  http POST {{baseUrl}}/tx-service/gno/api/v1/data-decoder/ \
  content-type:application/json \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'sessionid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "data": "",\n  "to": ""\n}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/data-decoder/

import Foundation

let headers = [
  "sessionid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "data": "",
  "to": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/data-decoder/")! 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}}/tx-service/gno/api/v1/delegates/");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/tx-service/gno/api/v1/delegates/" {:headers {:sessionid "{{apiKey}}"}
                                                                             :content-type :json
                                                                             :form-params {:safe ""
                                                                                           :delegate ""
                                                                                           :delegator ""
                                                                                           :signature ""
                                                                                           :label ""}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/delegates/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\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}}/tx-service/gno/api/v1/delegates/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\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}}/tx-service/gno/api/v1/delegates/");
var request = new RestRequest("", Method.Post);
request.AddHeader("sessionid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/delegates/"

	payload := strings.NewReader("{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\n}")

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

	req.Header.Add("sessionid", "{{apiKey}}")
	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/tx-service/gno/api/v1/delegates/ HTTP/1.1
Sessionid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tx-service/gno/api/v1/delegates/")
  .setHeader("sessionid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/delegates/"))
    .header("sessionid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\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  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/delegates/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/tx-service/gno/api/v1/delegates/")
  .header("sessionid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  safe: '',
  delegate: '',
  delegator: '',
  signature: '',
  label: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/tx-service/gno/api/v1/delegates/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/delegates/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {safe: '', delegate: '', delegator: '', signature: '', label: ''}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/delegates/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"safe":"","delegate":"","delegator":"","signature":"","label":""}'
};

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}}/tx-service/gno/api/v1/delegates/',
  method: 'POST',
  headers: {
    sessionid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "safe": "",\n  "delegate": "",\n  "delegator": "",\n  "signature": "",\n  "label": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/delegates/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .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/tx-service/gno/api/v1/delegates/',
  headers: {
    sessionid: '{{apiKey}}',
    '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({safe: '', delegate: '', delegator: '', signature: '', label: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/delegates/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {safe: '', delegate: '', delegator: '', signature: '', label: ''},
  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}}/tx-service/gno/api/v1/delegates/');

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

req.type('json');
req.send({
  safe: '',
  delegate: '',
  delegator: '',
  signature: '',
  label: ''
});

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}}/tx-service/gno/api/v1/delegates/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {safe: '', delegate: '', delegator: '', signature: '', label: ''}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/delegates/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"safe":"","delegate":"","delegator":"","signature":"","label":""}'
};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"safe": @"",
                              @"delegate": @"",
                              @"delegator": @"",
                              @"signature": @"",
                              @"label": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/delegates/"]
                                                       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}}/tx-service/gno/api/v1/delegates/" in
let headers = Header.add_list (Header.init ()) [
  ("sessionid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\n}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/delegates/",
  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([
    'safe' => '',
    'delegate' => '',
    'delegator' => '',
    'signature' => '',
    'label' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/tx-service/gno/api/v1/delegates/', [
  'body' => '{
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/delegates/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'safe' => '',
  'delegate' => '',
  'delegator' => '',
  'signature' => '',
  'label' => ''
]));

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

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

append(json_encode([
  'safe' => '',
  'delegate' => '',
  'delegator' => '',
  'signature' => '',
  'label' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/delegates/');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/delegates/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": ""
}'

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/delegates/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": ""
}'

import http.client

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

payload = "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\n}"

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

conn.request("POST", "/baseUrl/tx-service/gno/api/v1/delegates/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/delegates/"

payload = {
    "safe": "",
    "delegate": "",
    "delegator": "",
    "signature": "",
    "label": ""
}
headers = {
    "sessionid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/delegates/"

payload <- "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('sessionid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/delegates/")

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

request = Net::HTTP::Post.new(url)
request["sessionid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\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/tx-service/gno/api/v1/delegates/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
  req.body = "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/delegates/";

    let payload = json!({
        "safe": "",
        "delegate": "",
        "delegator": "",
        "signature": "",
        "label": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());
    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 '{
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": ""
}' |  \
  http POST {{baseUrl}}/tx-service/gno/api/v1/delegates/ \
  content-type:application/json \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'sessionid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "safe": "",\n  "delegate": "",\n  "delegator": "",\n  "signature": "",\n  "label": ""\n}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/delegates/

import Foundation

let headers = [
  "sessionid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/delegates/")! 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}}/tx-service/gno/api/v2/delegates/");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/tx-service/gno/api/v2/delegates/" {:headers {:sessionid "{{apiKey}}"}
                                                                             :content-type :json
                                                                             :form-params {:safe ""
                                                                                           :delegate ""
                                                                                           :delegator ""
                                                                                           :signature ""
                                                                                           :label ""
                                                                                           :expiryDate ""}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v2/delegates/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\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}}/tx-service/gno/api/v2/delegates/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\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}}/tx-service/gno/api/v2/delegates/");
var request = new RestRequest("", Method.Post);
request.AddHeader("sessionid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v2/delegates/"

	payload := strings.NewReader("{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\n}")

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

	req.Header.Add("sessionid", "{{apiKey}}")
	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/tx-service/gno/api/v2/delegates/ HTTP/1.1
Sessionid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": "",
  "expiryDate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tx-service/gno/api/v2/delegates/")
  .setHeader("sessionid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v2/delegates/"))
    .header("sessionid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\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  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/delegates/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/tx-service/gno/api/v2/delegates/")
  .header("sessionid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  safe: '',
  delegate: '',
  delegator: '',
  signature: '',
  label: '',
  expiryDate: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/tx-service/gno/api/v2/delegates/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v2/delegates/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    safe: '',
    delegate: '',
    delegator: '',
    signature: '',
    label: '',
    expiryDate: ''
  }
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v2/delegates/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"safe":"","delegate":"","delegator":"","signature":"","label":"","expiryDate":""}'
};

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}}/tx-service/gno/api/v2/delegates/',
  method: 'POST',
  headers: {
    sessionid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "safe": "",\n  "delegate": "",\n  "delegator": "",\n  "signature": "",\n  "label": "",\n  "expiryDate": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/delegates/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .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/tx-service/gno/api/v2/delegates/',
  headers: {
    sessionid: '{{apiKey}}',
    '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({
  safe: '',
  delegate: '',
  delegator: '',
  signature: '',
  label: '',
  expiryDate: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v2/delegates/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {
    safe: '',
    delegate: '',
    delegator: '',
    signature: '',
    label: '',
    expiryDate: ''
  },
  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}}/tx-service/gno/api/v2/delegates/');

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

req.type('json');
req.send({
  safe: '',
  delegate: '',
  delegator: '',
  signature: '',
  label: '',
  expiryDate: ''
});

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}}/tx-service/gno/api/v2/delegates/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    safe: '',
    delegate: '',
    delegator: '',
    signature: '',
    label: '',
    expiryDate: ''
  }
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v2/delegates/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"safe":"","delegate":"","delegator":"","signature":"","label":"","expiryDate":""}'
};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"safe": @"",
                              @"delegate": @"",
                              @"delegator": @"",
                              @"signature": @"",
                              @"label": @"",
                              @"expiryDate": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v2/delegates/"]
                                                       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}}/tx-service/gno/api/v2/delegates/" in
let headers = Header.add_list (Header.init ()) [
  ("sessionid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\n}" in

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

 "{{baseUrl}}/tx-service/gno/api/v2/delegates/",
  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([
    'safe' => '',
    'delegate' => '',
    'delegator' => '',
    'signature' => '',
    'label' => '',
    'expiryDate' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/tx-service/gno/api/v2/delegates/', [
  'body' => '{
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": "",
  "expiryDate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v2/delegates/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'safe' => '',
  'delegate' => '',
  'delegator' => '',
  'signature' => '',
  'label' => '',
  'expiryDate' => ''
]));

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

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

append(json_encode([
  'safe' => '',
  'delegate' => '',
  'delegator' => '',
  'signature' => '',
  'label' => '',
  'expiryDate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tx-service/gno/api/v2/delegates/');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v2/delegates/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": "",
  "expiryDate": ""
}'

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v2/delegates/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": "",
  "expiryDate": ""
}'

import http.client

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

payload = "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\n}"

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

conn.request("POST", "/baseUrl/tx-service/gno/api/v2/delegates/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v2/delegates/"

payload = {
    "safe": "",
    "delegate": "",
    "delegator": "",
    "signature": "",
    "label": "",
    "expiryDate": ""
}
headers = {
    "sessionid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v2/delegates/"

payload <- "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('sessionid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v2/delegates/")

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

request = Net::HTTP::Post.new(url)
request["sessionid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\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/tx-service/gno/api/v2/delegates/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
  req.body = "{\n  \"safe\": \"\",\n  \"delegate\": \"\",\n  \"delegator\": \"\",\n  \"signature\": \"\",\n  \"label\": \"\",\n  \"expiryDate\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v2/delegates/";

    let payload = json!({
        "safe": "",
        "delegate": "",
        "delegator": "",
        "signature": "",
        "label": "",
        "expiryDate": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());
    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 '{
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": "",
  "expiryDate": ""
}' |  \
  http POST {{baseUrl}}/tx-service/gno/api/v2/delegates/ \
  content-type:application/json \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'sessionid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "safe": "",\n  "delegate": "",\n  "delegator": "",\n  "signature": "",\n  "label": "",\n  "expiryDate": ""\n}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v2/delegates/

import Foundation

let headers = [
  "sessionid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "safe": "",
  "delegate": "",
  "delegator": "",
  "signature": "",
  "label": "",
  "expiryDate": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v2/delegates/")! 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}}/tx-service/gno/api/v1/delegates/:delegate_address/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/");
var request = new RestRequest("", Method.Delete);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

DELETE /baseUrl/tx-service/gno/api/v1/delegates/:delegate_address/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/delegates/:delegate_address/")
  .delete(null)
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/delegates/:delegate_address/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/';
const options = {method: 'DELETE', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/delegates/:delegate_address/',
  method: 'DELETE',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/")
  .delete(null)
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/delegates/:delegate_address/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/delegates/:delegate_address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/delegates/:delegate_address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/';
const options = {method: 'DELETE', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/tx-service/gno/api/v1/delegates/:delegate_address/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/' -Method DELETE -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/tx-service/gno/api/v1/delegates/:delegate_address/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/"

response <- VERB("DELETE", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/")

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

request = Net::HTTP::Delete.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.delete('/baseUrl/tx-service/gno/api/v1/delegates/:delegate_address/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/delegates/:delegate_address/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/");
var request = new RestRequest("", Method.Delete);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

DELETE /baseUrl/tx-service/gno/api/v2/delegates/:delegate_address/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v2/delegates/:delegate_address/")
  .delete(null)
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v2/delegates/:delegate_address/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/';
const options = {method: 'DELETE', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v2/delegates/:delegate_address/',
  method: 'DELETE',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/")
  .delete(null)
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v2/delegates/:delegate_address/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v2/delegates/:delegate_address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v2/delegates/:delegate_address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/';
const options = {method: 'DELETE', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/tx-service/gno/api/v2/delegates/:delegate_address/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/' -Method DELETE -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/tx-service/gno/api/v2/delegates/:delegate_address/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/"

response <- VERB("DELETE", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/")

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

request = Net::HTTP::Delete.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.delete('/baseUrl/tx-service/gno/api/v2/delegates/:delegate_address/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v2/delegates/:delegate_address/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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}}/tx-service/gno/api/v1/delegates/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/delegates/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/delegates/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/delegates/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/delegates/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/delegates/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/delegates/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/delegates/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/delegates/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/delegates/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/delegates/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/delegates/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/delegates/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/delegates/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/delegates/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/delegates/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/delegates/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/delegates/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/delegates/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/delegates/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/delegates/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/delegates/"]
                                                       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}}/tx-service/gno/api/v1/delegates/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/delegates/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/delegates/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/delegates/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/delegates/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/delegates/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/delegates/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/delegates/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/delegates/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/delegates/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/delegates/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/delegates/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/delegates/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/delegates/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/delegates/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/delegates/")! 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}}/tx-service/gno/api/v2/delegates/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v2/delegates/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v2/delegates/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v2/delegates/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v2/delegates/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v2/delegates/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v2/delegates/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v2/delegates/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v2/delegates/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v2/delegates/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v2/delegates/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v2/delegates/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v2/delegates/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v2/delegates/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v2/delegates/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/delegates/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v2/delegates/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v2/delegates/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v2/delegates/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v2/delegates/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v2/delegates/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v2/delegates/"]
                                                       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}}/tx-service/gno/api/v2/delegates/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v2/delegates/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v2/delegates/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v2/delegates/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v2/delegates/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v2/delegates/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v2/delegates/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v2/delegates/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v2/delegates/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v2/delegates/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v2/delegates/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v2/delegates/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v2/delegates/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v2/delegates/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v2/delegates/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v2/delegates/")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/");
var request = new RestRequest("", Method.Delete);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

DELETE /baseUrl/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/")
  .delete(null)
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/';
const options = {method: 'DELETE', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/',
  method: 'DELETE',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/")
  .delete(null)
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/';
const options = {method: 'DELETE', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/' -Method DELETE -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/"

response <- VERB("DELETE", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/")

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

request = Net::HTTP::Delete.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.delete('/baseUrl/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/delegates/:delegate_address/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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}}/tx-service/gno/api/v1/messages/:message_hash/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/messages/:message_hash/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/messages/:message_hash/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/messages/:message_hash/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/messages/:message_hash/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/messages/:message_hash/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/messages/:message_hash/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/messages/:message_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/messages/:message_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/"]
                                                       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}}/tx-service/gno/api/v1/messages/:message_hash/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/messages/:message_hash/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/messages/:message_hash/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/messages/:message_hash/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/")! 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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"signature\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/" {:headers {:sessionid "{{apiKey}}"}
                                                                                                     :content-type :json
                                                                                                     :form-params {:signature ""}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"signature\": \"\"\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}}/tx-service/gno/api/v1/messages/:message_hash/signatures/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"signature\": \"\"\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}}/tx-service/gno/api/v1/messages/:message_hash/signatures/");
var request = new RestRequest("", Method.Post);
request.AddHeader("sessionid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"signature\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/"

	payload := strings.NewReader("{\n  \"signature\": \"\"\n}")

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

	req.Header.Add("sessionid", "{{apiKey}}")
	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/tx-service/gno/api/v1/messages/:message_hash/signatures/ HTTP/1.1
Sessionid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "signature": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/")
  .setHeader("sessionid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"signature\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/"))
    .header("sessionid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"signature\": \"\"\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  \"signature\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/")
  .header("sessionid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"signature\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {signature: ''}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"signature":""}'
};

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}}/tx-service/gno/api/v1/messages/:message_hash/signatures/',
  method: 'POST',
  headers: {
    sessionid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "signature": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"signature\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .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/tx-service/gno/api/v1/messages/:message_hash/signatures/',
  headers: {
    sessionid: '{{apiKey}}',
    '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({signature: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {signature: ''},
  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}}/tx-service/gno/api/v1/messages/:message_hash/signatures/');

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

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

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}}/tx-service/gno/api/v1/messages/:message_hash/signatures/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {signature: ''}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"signature":""}'
};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"signature": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/"]
                                                       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}}/tx-service/gno/api/v1/messages/:message_hash/signatures/" in
let headers = Header.add_list (Header.init ()) [
  ("sessionid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"signature\": \"\"\n}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/",
  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([
    'signature' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/', [
  'body' => '{
  "signature": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

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

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

append(json_encode([
  'signature' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "signature": ""
}'

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "signature": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/tx-service/gno/api/v1/messages/:message_hash/signatures/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/"

payload = { "signature": "" }
headers = {
    "sessionid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/"

payload <- "{\n  \"signature\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('sessionid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/")

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

request = Net::HTTP::Post.new(url)
request["sessionid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"signature\": \"\"\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/tx-service/gno/api/v1/messages/:message_hash/signatures/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
  req.body = "{\n  \"signature\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());
    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 '{
  "signature": ""
}' |  \
  http POST {{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/ \
  content-type:application/json \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'sessionid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "signature": ""\n}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/

import Foundation

let headers = [
  "sessionid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["signature": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/messages/:message_hash/signatures/")! 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}}/tx-service/gno/api/v1/safes/:address/messages/");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/" {:headers {:sessionid "{{apiKey}}"}
                                                                                           :content-type :json
                                                                                           :form-params {:message ""
                                                                                                         :safeAppId ""
                                                                                                         :signature ""
                                                                                                         :origin ""}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\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}}/tx-service/gno/api/v1/safes/:address/messages/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\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}}/tx-service/gno/api/v1/safes/:address/messages/");
var request = new RestRequest("", Method.Post);
request.AddHeader("sessionid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"

	payload := strings.NewReader("{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")

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

	req.Header.Add("sessionid", "{{apiKey}}")
	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/tx-service/gno/api/v1/safes/:address/messages/ HTTP/1.1
Sessionid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 73

{
  "message": "",
  "safeAppId": "",
  "signature": "",
  "origin": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/")
  .setHeader("sessionid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"))
    .header("sessionid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\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  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/")
  .header("sessionid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  message: '',
  safeAppId: '',
  signature: '',
  origin: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {message: '', safeAppId: '', signature: '', origin: ''}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"message":"","safeAppId":"","signature":"","origin":""}'
};

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}}/tx-service/gno/api/v1/safes/:address/messages/',
  method: 'POST',
  headers: {
    sessionid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "message": "",\n  "safeAppId": "",\n  "signature": "",\n  "origin": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .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/tx-service/gno/api/v1/safes/:address/messages/',
  headers: {
    sessionid: '{{apiKey}}',
    '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({message: '', safeAppId: '', signature: '', origin: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {message: '', safeAppId: '', signature: '', origin: ''},
  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}}/tx-service/gno/api/v1/safes/:address/messages/');

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

req.type('json');
req.send({
  message: '',
  safeAppId: '',
  signature: '',
  origin: ''
});

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}}/tx-service/gno/api/v1/safes/:address/messages/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {message: '', safeAppId: '', signature: '', origin: ''}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"message":"","safeAppId":"","signature":"","origin":""}'
};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"message": @"",
                              @"safeAppId": @"",
                              @"signature": @"",
                              @"origin": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/messages/" in
let headers = Header.add_list (Header.init ()) [
  ("sessionid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/",
  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([
    'message' => '',
    'safeAppId' => '',
    'signature' => '',
    'origin' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/', [
  'body' => '{
  "message": "",
  "safeAppId": "",
  "signature": "",
  "origin": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'message' => '',
  'safeAppId' => '',
  'signature' => '',
  'origin' => ''
]));

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

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

append(json_encode([
  'message' => '',
  'safeAppId' => '',
  'signature' => '',
  'origin' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "message": "",
  "safeAppId": "",
  "signature": "",
  "origin": ""
}'

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "message": "",
  "safeAppId": "",
  "signature": "",
  "origin": ""
}'

import http.client

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

payload = "{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}"

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

conn.request("POST", "/baseUrl/tx-service/gno/api/v1/safes/:address/messages/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"

payload = {
    "message": "",
    "safeAppId": "",
    "signature": "",
    "origin": ""
}
headers = {
    "sessionid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"

payload <- "{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('sessionid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/")

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

request = Net::HTTP::Post.new(url)
request["sessionid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\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/tx-service/gno/api/v1/safes/:address/messages/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
  req.body = "{\n  \"message\": \"\",\n  \"safeAppId\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/";

    let payload = json!({
        "message": "",
        "safeAppId": "",
        "signature": "",
        "origin": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());
    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 '{
  "message": "",
  "safeAppId": "",
  "signature": "",
  "origin": ""
}' |  \
  http POST {{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/ \
  content-type:application/json \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'sessionid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "message": "",\n  "safeAppId": "",\n  "signature": "",\n  "origin": ""\n}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/

import Foundation

let headers = [
  "sessionid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "message": "",
  "safeAppId": "",
  "signature": "",
  "origin": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safes/:address/messages/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/safes/:address/messages/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safes/:address/messages/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safes/:address/messages/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safes/:address/messages/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safes/:address/messages/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safes/:address/messages/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safes/:address/messages/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/messages/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safes/:address/messages/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/safes/:address/messages/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safes/:address/messages/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/messages/")! 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}}/tx-service/gno/api/v1/modules/:address/safes/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/modules/:address/safes/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/modules/:address/safes/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/modules/:address/safes/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/modules/:address/safes/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/modules/:address/safes/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/modules/:address/safes/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/modules/:address/safes/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/modules/:address/safes/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/"]
                                                       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}}/tx-service/gno/api/v1/modules/:address/safes/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/' -Method GET -Headers $headers

import http.client

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

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/modules/:address/safes/", headers=headers)

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

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

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/")

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

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/tx-service/gno/api/v1/modules/:address/safes/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/modules/:address/safes/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/modules/:address/safes/")! 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}}/tx-service/gno/api/v1/owners/:address/safes/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/owners/:address/safes/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/"

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

	req.Header.Add("sessionid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/tx-service/gno/api/v1/owners/:address/safes/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/owners/:address/safes/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/owners/:address/safes/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/',
  headers: {sessionid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/owners/:address/safes/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/owners/:address/safes/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/owners/:address/safes/',
  headers: {sessionid: '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/owners/:address/safes/',
  headers: {sessionid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/"]
                                                       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}}/tx-service/gno/api/v1/owners/:address/safes/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

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

 "{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/owners/:address/safes/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/owners/:address/safes/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/owners/:address/safes/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/owners/:address/safes/")! 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}}/tx-service/gno/api/v1/safes/:address/balances/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safes/:address/balances/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/safes/:address/balances/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safes/:address/balances/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safes/:address/balances/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safes/:address/balances/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safes/:address/balances/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safes/:address/balances/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safes/:address/balances/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/balances/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safes/:address/balances/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/safes/:address/balances/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safes/:address/balances/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/balances/")! 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}}/tx-service/gno/api/v2/safes/:address/balances/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v2/safes/:address/balances/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v2/safes/:address/balances/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v2/safes/:address/balances/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v2/safes/:address/balances/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v2/safes/:address/balances/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v2/safes/:address/balances/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v2/safes/:address/balances/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v2/safes/:address/balances/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/"]
                                                       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}}/tx-service/gno/api/v2/safes/:address/balances/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v2/safes/:address/balances/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v2/safes/:address/balances/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v2/safes/:address/balances/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/balances/")! 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}}/tx-service/gno/api/v2/safes/:address/collectibles/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v2/safes/:address/collectibles/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v2/safes/:address/collectibles/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v2/safes/:address/collectibles/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v2/safes/:address/collectibles/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v2/safes/:address/collectibles/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v2/safes/:address/collectibles/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v2/safes/:address/collectibles/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v2/safes/:address/collectibles/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/"]
                                                       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}}/tx-service/gno/api/v2/safes/:address/collectibles/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v2/safes/:address/collectibles/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v2/safes/:address/collectibles/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v2/safes/:address/collectibles/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/collectibles/")! 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}}/tx-service/gno/api/v1/safes/:address/creation/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safes/:address/creation/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/safes/:address/creation/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safes/:address/creation/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safes/:address/creation/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safes/:address/creation/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safes/:address/creation/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safes/:address/creation/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safes/:address/creation/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/creation/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safes/:address/creation/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/safes/:address/creation/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safes/:address/creation/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/creation/")! 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}}/tx-service/gno/api/v1/safes/:address/export/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safes/:address/export/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/safes/:address/export/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safes/:address/export/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safes/:address/export/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safes/:address/export/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safes/:address/export/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safes/:address/export/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safes/:address/export/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/export/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safes/:address/export/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/safes/:address/export/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safes/:address/export/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/export/")! 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}}/tx-service/gno/api/v1/safes/:address/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safes/:address/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/safes/:address/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safes/:address/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safes/:address/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safes/:address/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safes/:address/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safes/:address/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safes/:address/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safes/:address/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/safes/:address/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safes/:address/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/")! 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}}/tx-service/gno/api/v1/tokens/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/tokens/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/tokens/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/tokens/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/tokens/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/tokens/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/tokens/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/tokens/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/tokens/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/tokens/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/tokens/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/tokens/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/tokens/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/tokens/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/tokens/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/tokens/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/tokens/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/tokens/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/tokens/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/tokens/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/tokens/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/tokens/"]
                                                       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}}/tx-service/gno/api/v1/tokens/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/tokens/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/tokens/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/tokens/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/tokens/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/tokens/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/tokens/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/tokens/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/tokens/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/tokens/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/tokens/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/tokens/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/tokens/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/tokens/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/tokens/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/tokens/")! 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}}/tx-service/gno/api/v1/tokens/lists/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/tokens/lists/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/tokens/lists/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/tokens/lists/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/tokens/lists/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/tokens/lists/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/tokens/lists/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/tokens/lists/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/tokens/lists/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/"]
                                                       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}}/tx-service/gno/api/v1/tokens/lists/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/tokens/lists/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/tokens/lists/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/tokens/lists/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/tokens/lists/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/tokens/lists/")! 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}}/tx-service/gno/api/v1/tokens/:address/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/tokens/:address/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/tokens/:address/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/tokens/:address/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/tokens/:address/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/tokens/:address/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/tokens/:address/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/tokens/:address/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/tokens/:address/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/"]
                                                       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}}/tx-service/gno/api/v1/tokens/:address/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/tokens/:address/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/tokens/:address/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/tokens/:address/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/tokens/:address/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/tokens/:address/")! 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}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/module-transaction/:module_transaction_id HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/module-transaction/:module_transaction_id',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id"]
                                                       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}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/module-transaction/:module_transaction_id", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/module-transaction/:module_transaction_id') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/module-transaction/:module_transaction_id")! 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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"signature\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/" {:headers {:sessionid "{{apiKey}}"}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:signature ""}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"signature\": \"\"\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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"signature\": \"\"\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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/");
var request = new RestRequest("", Method.Post);
request.AddHeader("sessionid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"signature\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"

	payload := strings.NewReader("{\n  \"signature\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("sessionid", "{{apiKey}}")
	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/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/ HTTP/1.1
Sessionid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "signature": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")
  .setHeader("sessionid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"signature\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"))
    .header("sessionid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"signature\": \"\"\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  \"signature\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")
  .header("sessionid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"signature\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  signature: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {signature: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"signature":""}'
};

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/',
  method: 'POST',
  headers: {
    sessionid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "signature": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"signature\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .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/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/',
  headers: {
    sessionid: '{{apiKey}}',
    '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({signature: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {signature: ''},
  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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/');

req.headers({
  sessionid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  signature: ''
});

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {signature: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"signature":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"signature": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"]
                                                       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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/" in
let headers = Header.add_list (Header.init ()) [
  ("sessionid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"signature\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/",
  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([
    'signature' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/', [
  'body' => '{
  "signature": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'signature' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'signature' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "signature": ""
}'

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "signature": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"signature\": \"\"\n}"

headers = {
    'sessionid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"

payload = { "signature": "" }
headers = {
    "sessionid": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"

payload <- "{\n  \"signature\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('sessionid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["sessionid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"signature\": \"\"\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/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
  req.body = "{\n  \"signature\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/";

    let payload = json!({"signature": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());
    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 '{
  "signature": ""
}' |  \
  http POST {{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/ \
  content-type:application/json \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'sessionid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "signature": ""\n}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/

import Foundation

let headers = [
  "sessionid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["signature": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"]
                                                       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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/confirmations/")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/");
var request = new RestRequest("", Method.Delete);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")
  .delete(null)
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/';
const options = {method: 'DELETE', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/',
  method: 'DELETE',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")
  .delete(null)
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/';
const options = {method: 'DELETE', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"

response <- VERB("DELETE", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/");
var request = new RestRequest("", Method.Delete);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")
  .delete(null)
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/';
const options = {method: 'DELETE', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/',
  method: 'DELETE',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")
  .delete(null)
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/';
const options = {method: 'DELETE', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"

response <- VERB("DELETE", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"]
                                                       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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/multisig-transactions/:safe_tx_hash/")! 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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"]
                                                       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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v2/multisig-transactions/:safe_tx_hash/")! 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}}/tx-service/gno/api/v1/safes/:address/all-transactions/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safes/:address/all-transactions/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/safes/:address/all-transactions/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safes/:address/all-transactions/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safes/:address/all-transactions/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safes/:address/all-transactions/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safes/:address/all-transactions/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safes/:address/all-transactions/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safes/:address/all-transactions/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/all-transactions/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safes/:address/all-transactions/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/safes/:address/all-transactions/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safes/:address/all-transactions/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/all-transactions/")! 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}}/tx-service/gno/api/v2/safes/:address/all-transactions/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v2/safes/:address/all-transactions/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v2/safes/:address/all-transactions/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v2/safes/:address/all-transactions/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v2/safes/:address/all-transactions/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v2/safes/:address/all-transactions/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v2/safes/:address/all-transactions/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v2/safes/:address/all-transactions/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v2/safes/:address/all-transactions/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/"]
                                                       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}}/tx-service/gno/api/v2/safes/:address/all-transactions/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v2/safes/:address/all-transactions/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v2/safes/:address/all-transactions/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v2/safes/:address/all-transactions/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/all-transactions/")! 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}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/safes/:address/incoming-transfers/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safes/:address/incoming-transfers/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safes/:address/incoming-transfers/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/safes/:address/incoming-transfers/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/incoming-transfers/")! 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}}/tx-service/gno/api/v1/safes/:address/module-transactions/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/" {:headers {:sessionid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
}

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}}/tx-service/gno/api/v1/safes/:address/module-transactions/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/");
var request = new RestRequest("", Method.Get);
request.AddHeader("sessionid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("sessionid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tx-service/gno/api/v1/safes/:address/module-transactions/ HTTP/1.1
Sessionid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/")
  .setHeader("sessionid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/"))
    .header("sessionid", "{{apiKey}}")
    .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}}/tx-service/gno/api/v1/safes/:address/module-transactions/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/")
  .header("sessionid", "{{apiKey}}")
  .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}}/tx-service/gno/api/v1/safes/:address/module-transactions/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

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}}/tx-service/gno/api/v1/safes/:address/module-transactions/',
  method: 'GET',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/")
  .get()
  .addHeader("sessionid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tx-service/gno/api/v1/safes/:address/module-transactions/',
  headers: {
    sessionid: '{{apiKey}}'
  }
};

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}}/tx-service/gno/api/v1/safes/:address/module-transactions/',
  headers: {sessionid: '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/');

req.headers({
  sessionid: '{{apiKey}}'
});

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}}/tx-service/gno/api/v1/safes/:address/module-transactions/',
  headers: {sessionid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/';
const options = {method: 'GET', headers: {sessionid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/module-transactions/" in
let headers = Header.add (Header.init ()) "sessionid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/', [
  'headers' => [
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/');
$request->setRequestMethod('GET');
$request->setHeaders([
  'sessionid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/' -Method GET -Headers $headers

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'sessionid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/tx-service/gno/api/v1/safes/:address/module-transactions/", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/"

headers = {"sessionid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/"

response <- VERB("GET", url, add_headers('sessionid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["sessionid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tx-service/gno/api/v1/safes/:address/module-transactions/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".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}}/tx-service/gno/api/v1/safes/:address/module-transactions/ \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'sessionid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/

import Foundation

let headers = ["sessionid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/module-transactions/")! 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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/" {:headers {:sessionid "{{apiKey}}"}
                                                                                                        :content-type :json
                                                                                                        :form-params {:safe ""
                                                                                                                      :to ""
                                                                                                                      :value 0
                                                                                                                      :data ""
                                                                                                                      :operation 0
                                                                                                                      :gasToken ""
                                                                                                                      :safeTxGas 0
                                                                                                                      :baseGas 0
                                                                                                                      :gasPrice 0
                                                                                                                      :refundReceiver ""
                                                                                                                      :nonce 0
                                                                                                                      :contractTransactionHash ""
                                                                                                                      :sender ""
                                                                                                                      :signature ""
                                                                                                                      :origin ""}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\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}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\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}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/");
var request = new RestRequest("", Method.Post);
request.AddHeader("sessionid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/"

	payload := strings.NewReader("{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("sessionid", "{{apiKey}}")
	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/tx-service/gno/api/v1/safes/:address/multisig-transactions/ HTTP/1.1
Sessionid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 265

{
  "safe": "",
  "to": "",
  "value": 0,
  "data": "",
  "operation": 0,
  "gasToken": "",
  "safeTxGas": 0,
  "baseGas": 0,
  "gasPrice": 0,
  "refundReceiver": "",
  "nonce": 0,
  "contractTransactionHash": "",
  "sender": "",
  "signature": "",
  "origin": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/")
  .setHeader("sessionid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/"))
    .header("sessionid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\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  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/")
  .header("sessionid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  safe: '',
  to: '',
  value: 0,
  data: '',
  operation: 0,
  gasToken: '',
  safeTxGas: 0,
  baseGas: 0,
  gasPrice: 0,
  refundReceiver: '',
  nonce: 0,
  contractTransactionHash: '',
  sender: '',
  signature: '',
  origin: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    safe: '',
    to: '',
    value: 0,
    data: '',
    operation: 0,
    gasToken: '',
    safeTxGas: 0,
    baseGas: 0,
    gasPrice: 0,
    refundReceiver: '',
    nonce: 0,
    contractTransactionHash: '',
    sender: '',
    signature: '',
    origin: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"safe":"","to":"","value":0,"data":"","operation":0,"gasToken":"","safeTxGas":0,"baseGas":0,"gasPrice":0,"refundReceiver":"","nonce":0,"contractTransactionHash":"","sender":"","signature":"","origin":""}'
};

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}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/',
  method: 'POST',
  headers: {
    sessionid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "safe": "",\n  "to": "",\n  "value": 0,\n  "data": "",\n  "operation": 0,\n  "gasToken": "",\n  "safeTxGas": 0,\n  "baseGas": 0,\n  "gasPrice": 0,\n  "refundReceiver": "",\n  "nonce": 0,\n  "contractTransactionHash": "",\n  "sender": "",\n  "signature": "",\n  "origin": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .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/tx-service/gno/api/v1/safes/:address/multisig-transactions/',
  headers: {
    sessionid: '{{apiKey}}',
    '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({
  safe: '',
  to: '',
  value: 0,
  data: '',
  operation: 0,
  gasToken: '',
  safeTxGas: 0,
  baseGas: 0,
  gasPrice: 0,
  refundReceiver: '',
  nonce: 0,
  contractTransactionHash: '',
  sender: '',
  signature: '',
  origin: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {
    safe: '',
    to: '',
    value: 0,
    data: '',
    operation: 0,
    gasToken: '',
    safeTxGas: 0,
    baseGas: 0,
    gasPrice: 0,
    refundReceiver: '',
    nonce: 0,
    contractTransactionHash: '',
    sender: '',
    signature: '',
    origin: ''
  },
  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}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/');

req.headers({
  sessionid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  safe: '',
  to: '',
  value: 0,
  data: '',
  operation: 0,
  gasToken: '',
  safeTxGas: 0,
  baseGas: 0,
  gasPrice: 0,
  refundReceiver: '',
  nonce: 0,
  contractTransactionHash: '',
  sender: '',
  signature: '',
  origin: ''
});

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}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    safe: '',
    to: '',
    value: 0,
    data: '',
    operation: 0,
    gasToken: '',
    safeTxGas: 0,
    baseGas: 0,
    gasPrice: 0,
    refundReceiver: '',
    nonce: 0,
    contractTransactionHash: '',
    sender: '',
    signature: '',
    origin: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"safe":"","to":"","value":0,"data":"","operation":0,"gasToken":"","safeTxGas":0,"baseGas":0,"gasPrice":0,"refundReceiver":"","nonce":0,"contractTransactionHash":"","sender":"","signature":"","origin":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"safe": @"",
                              @"to": @"",
                              @"value": @0,
                              @"data": @"",
                              @"operation": @0,
                              @"gasToken": @"",
                              @"safeTxGas": @0,
                              @"baseGas": @0,
                              @"gasPrice": @0,
                              @"refundReceiver": @"",
                              @"nonce": @0,
                              @"contractTransactionHash": @"",
                              @"sender": @"",
                              @"signature": @"",
                              @"origin": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/"]
                                                       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}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/" in
let headers = Header.add_list (Header.init ()) [
  ("sessionid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/",
  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([
    'safe' => '',
    'to' => '',
    'value' => 0,
    'data' => '',
    'operation' => 0,
    'gasToken' => '',
    'safeTxGas' => 0,
    'baseGas' => 0,
    'gasPrice' => 0,
    'refundReceiver' => '',
    'nonce' => 0,
    'contractTransactionHash' => '',
    'sender' => '',
    'signature' => '',
    'origin' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/', [
  'body' => '{
  "safe": "",
  "to": "",
  "value": 0,
  "data": "",
  "operation": 0,
  "gasToken": "",
  "safeTxGas": 0,
  "baseGas": 0,
  "gasPrice": 0,
  "refundReceiver": "",
  "nonce": 0,
  "contractTransactionHash": "",
  "sender": "",
  "signature": "",
  "origin": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'safe' => '',
  'to' => '',
  'value' => 0,
  'data' => '',
  'operation' => 0,
  'gasToken' => '',
  'safeTxGas' => 0,
  'baseGas' => 0,
  'gasPrice' => 0,
  'refundReceiver' => '',
  'nonce' => 0,
  'contractTransactionHash' => '',
  'sender' => '',
  'signature' => '',
  'origin' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'safe' => '',
  'to' => '',
  'value' => 0,
  'data' => '',
  'operation' => 0,
  'gasToken' => '',
  'safeTxGas' => 0,
  'baseGas' => 0,
  'gasPrice' => 0,
  'refundReceiver' => '',
  'nonce' => 0,
  'contractTransactionHash' => '',
  'sender' => '',
  'signature' => '',
  'origin' => ''
]));
$request->setRequestUrl('{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'sessionid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "safe": "",
  "to": "",
  "value": 0,
  "data": "",
  "operation": 0,
  "gasToken": "",
  "safeTxGas": 0,
  "baseGas": 0,
  "gasPrice": 0,
  "refundReceiver": "",
  "nonce": 0,
  "contractTransactionHash": "",
  "sender": "",
  "signature": "",
  "origin": ""
}'

$headers=@{}
$headers.Add("sessionid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "safe": "",
  "to": "",
  "value": 0,
  "data": "",
  "operation": 0,
  "gasToken": "",
  "safeTxGas": 0,
  "baseGas": 0,
  "gasPrice": 0,
  "refundReceiver": "",
  "nonce": 0,
  "contractTransactionHash": "",
  "sender": "",
  "signature": "",
  "origin": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}"

headers = {
    'sessionid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/tx-service/gno/api/v1/safes/:address/multisig-transactions/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/"

payload = {
    "safe": "",
    "to": "",
    "value": 0,
    "data": "",
    "operation": 0,
    "gasToken": "",
    "safeTxGas": 0,
    "baseGas": 0,
    "gasPrice": 0,
    "refundReceiver": "",
    "nonce": 0,
    "contractTransactionHash": "",
    "sender": "",
    "signature": "",
    "origin": ""
}
headers = {
    "sessionid": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/"

payload <- "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('sessionid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["sessionid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\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/tx-service/gno/api/v1/safes/:address/multisig-transactions/') do |req|
  req.headers['sessionid'] = '{{apiKey}}'
  req.body = "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/";

    let payload = json!({
        "safe": "",
        "to": "",
        "value": 0,
        "data": "",
        "operation": 0,
        "gasToken": "",
        "safeTxGas": 0,
        "baseGas": 0,
        "gasPrice": 0,
        "refundReceiver": "",
        "nonce": 0,
        "contractTransactionHash": "",
        "sender": "",
        "signature": "",
        "origin": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("sessionid", "{{apiKey}}".parse().unwrap());
    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 '{
  "safe": "",
  "to": "",
  "value": 0,
  "data": "",
  "operation": 0,
  "gasToken": "",
  "safeTxGas": 0,
  "baseGas": 0,
  "gasPrice": 0,
  "refundReceiver": "",
  "nonce": 0,
  "contractTransactionHash": "",
  "sender": "",
  "signature": "",
  "origin": ""
}' |  \
  http POST {{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/ \
  content-type:application/json \
  sessionid:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'sessionid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "safe": "",\n  "to": "",\n  "value": 0,\n  "data": "",\n  "operation": 0,\n  "gasToken": "",\n  "safeTxGas": 0,\n  "baseGas": 0,\n  "gasPrice": 0,\n  "refundReceiver": "",\n  "nonce": 0,\n  "contractTransactionHash": "",\n  "sender": "",\n  "signature": "",\n  "origin": ""\n}' \
  --output-document \
  - {{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/

import Foundation

let headers = [
  "sessionid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "safe": "",
  "to": "",
  "value": 0,
  "data": "",
  "operation": 0,
  "gasToken": "",
  "safeTxGas": 0,
  "baseGas": 0,
  "gasPrice": 0,
  "refundReceiver": "",
  "nonce": 0,
  "contractTransactionHash": "",
  "sender": "",
  "signature": "",
  "origin": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tx-service/gno/api/v1/safes/:address/multisig-transactions/")! 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}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "sessionid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/" {:headers {:sessionid "{{apiKey}}"}
                                                                                                        :content-type :json
                                                                                                        :form-params {:safe ""
                                                                                                                      :to ""
                                                                                                                      :value 0
                                                                                                                      :data ""
                                                                                                                      :operation 0
                                                                                                                      :gasToken ""
                                                                                                                      :safeTxGas 0
                                                                                                                      :baseGas 0
                                                                                                                      :gasPrice 0
                                                                                                                      :refundReceiver ""
                                                                                                                      :nonce 0
                                                                                                                      :contractTransactionHash ""
                                                                                                                      :sender ""
                                                                                                                      :signature ""
                                                                                                                      :origin ""}})

require "http/client"

url = "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/"
headers = HTTP::Headers{
  "sessionid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\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}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/"),
    Headers =
    {
        { "sessionid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\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}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/");
var request = new RestRequest("", Method.Post);
request.AddHeader("sessionid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/"

	payload := strings.NewReader("{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("sessionid", "{{apiKey}}")
	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/tx-service/gno/api/v2/safes/:address/multisig-transactions/ HTTP/1.1
Sessionid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 265

{
  "safe": "",
  "to": "",
  "value": 0,
  "data": "",
  "operation": 0,
  "gasToken": "",
  "safeTxGas": 0,
  "baseGas": 0,
  "gasPrice": 0,
  "refundReceiver": "",
  "nonce": 0,
  "contractTransactionHash": "",
  "sender": "",
  "signature": "",
  "origin": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/")
  .setHeader("sessionid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/"))
    .header("sessionid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\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  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/")
  .header("sessionid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  safe: '',
  to: '',
  value: 0,
  data: '',
  operation: 0,
  gasToken: '',
  safeTxGas: 0,
  baseGas: 0,
  gasPrice: 0,
  refundReceiver: '',
  nonce: 0,
  contractTransactionHash: '',
  sender: '',
  signature: '',
  origin: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/');
xhr.setRequestHeader('sessionid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    safe: '',
    to: '',
    value: 0,
    data: '',
    operation: 0,
    gasToken: '',
    safeTxGas: 0,
    baseGas: 0,
    gasPrice: 0,
    refundReceiver: '',
    nonce: 0,
    contractTransactionHash: '',
    sender: '',
    signature: '',
    origin: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"safe":"","to":"","value":0,"data":"","operation":0,"gasToken":"","safeTxGas":0,"baseGas":0,"gasPrice":0,"refundReceiver":"","nonce":0,"contractTransactionHash":"","sender":"","signature":"","origin":""}'
};

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}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/',
  method: 'POST',
  headers: {
    sessionid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "safe": "",\n  "to": "",\n  "value": 0,\n  "data": "",\n  "operation": 0,\n  "gasToken": "",\n  "safeTxGas": 0,\n  "baseGas": 0,\n  "gasPrice": 0,\n  "refundReceiver": "",\n  "nonce": 0,\n  "contractTransactionHash": "",\n  "sender": "",\n  "signature": "",\n  "origin": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/")
  .post(body)
  .addHeader("sessionid", "{{apiKey}}")
  .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/tx-service/gno/api/v2/safes/:address/multisig-transactions/',
  headers: {
    sessionid: '{{apiKey}}',
    '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({
  safe: '',
  to: '',
  value: 0,
  data: '',
  operation: 0,
  gasToken: '',
  safeTxGas: 0,
  baseGas: 0,
  gasPrice: 0,
  refundReceiver: '',
  nonce: 0,
  contractTransactionHash: '',
  sender: '',
  signature: '',
  origin: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {
    safe: '',
    to: '',
    value: 0,
    data: '',
    operation: 0,
    gasToken: '',
    safeTxGas: 0,
    baseGas: 0,
    gasPrice: 0,
    refundReceiver: '',
    nonce: 0,
    contractTransactionHash: '',
    sender: '',
    signature: '',
    origin: ''
  },
  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}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/');

req.headers({
  sessionid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  safe: '',
  to: '',
  value: 0,
  data: '',
  operation: 0,
  gasToken: '',
  safeTxGas: 0,
  baseGas: 0,
  gasPrice: 0,
  refundReceiver: '',
  nonce: 0,
  contractTransactionHash: '',
  sender: '',
  signature: '',
  origin: ''
});

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}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {
    safe: '',
    to: '',
    value: 0,
    data: '',
    operation: 0,
    gasToken: '',
    safeTxGas: 0,
    baseGas: 0,
    gasPrice: 0,
    refundReceiver: '',
    nonce: 0,
    contractTransactionHash: '',
    sender: '',
    signature: '',
    origin: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/';
const options = {
  method: 'POST',
  headers: {sessionid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"safe":"","to":"","value":0,"data":"","operation":0,"gasToken":"","safeTxGas":0,"baseGas":0,"gasPrice":0,"refundReceiver":"","nonce":0,"contractTransactionHash":"","sender":"","signature":"","origin":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"sessionid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"safe": @"",
                              @"to": @"",
                              @"value": @0,
                              @"data": @"",
                              @"operation": @0,
                              @"gasToken": @"",
                              @"safeTxGas": @0,
                              @"baseGas": @0,
                              @"gasPrice": @0,
                              @"refundReceiver": @"",
                              @"nonce": @0,
                              @"contractTransactionHash": @"",
                              @"sender": @"",
                              @"signature": @"",
                              @"origin": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/"]
                                                       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}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/" in
let headers = Header.add_list (Header.init ()) [
  ("sessionid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"safe\": \"\",\n  \"to\": \"\",\n  \"value\": 0,\n  \"data\": \"\",\n  \"operation\": 0,\n  \"gasToken\": \"\",\n  \"safeTxGas\": 0,\n  \"baseGas\": 0,\n  \"gasPrice\": 0,\n  \"refundReceiver\": \"\",\n  \"nonce\": 0,\n  \"contractTransactionHash\": \"\",\n  \"sender\": \"\",\n  \"signature\": \"\",\n  \"origin\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/",
  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([
    'safe' => '',
    'to' => '',
    'value' => 0,
    'data' => '',
    'operation' => 0,
    'gasToken' => '',
    'safeTxGas' => 0,
    'baseGas' => 0,
    'gasPrice' => 0,
    'refundReceiver' => '',
    'nonce' => 0,
    'contractTransactionHash' => '',
    'sender' => '',
    'signature' => '',
    'origin' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "sessionid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/tx-service/gno/api/v2/safes/:address/multisig-transactions/', [
  'body' => '{
  "safe": "",
  "to": "",
  "value": 0,
  "data": "",
  "operation": 0,
  "gasToken": "",
  "safeTxGas": 0,
  "baseGas": 0,
  "gasPrice": 0,
  "refundReceiver": "",
  "nonce": 0,
  "contractTransactionHash": "",
  "sender": "",
  "signature": "",
  "origin": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'sessionid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();